@angular-eslint/eslint-plugin-template 20.3.1-alpha.14 → 20.3.1-alpha.15

package/README.md

@@ -63,6 +63,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`no-interpolation-in-attributes`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-interpolation-in-attributes.md) | Ensures that property-binding is used instead of interpolation in attributes. |  | :wrench: |  |  |
 | [`no-negated-async`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-negated-async.md) | Ensures that async pipe results, as well as values used with the async pipe, are not negated | :white_check_mark: |  | :bulb: |  |
 | [`no-positive-tabindex`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-positive-tabindex.md) | Ensures that the `tabindex` attribute is not positive |  |  | :bulb: |  |
+| [`prefer-at-else`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-at-else.md) | Prefer using `@else` instead of a second `@if` with the opposite condition to reduce code and make it easier to read. |  | :wrench: |  |  |
 | [`prefer-at-empty`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-at-empty.md) | Prefer using `@empty` with `@for` loops instead of a separate `@if` or `@else` block to reduce code and make it easier to read. |  | :wrench: |  |  |
 | [`prefer-contextual-for-variables`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-contextual-for-variables.md) | Ensures that contextual variables are used in @for blocks where possible instead of aliasing them. |  | :wrench: |  |  |
 | [`prefer-control-flow`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-control-flow.md) | Ensures that the built-in control flow is used. |  |  |  |  |

package/dist/configs/all.json

@@ -26,6 +26,7 @@
         "@angular-eslint/template/no-negated-async": "error",
         "@angular-eslint/template/no-nested-tags": "error",
         "@angular-eslint/template/no-positive-tabindex": "error",
+        "@angular-eslint/template/prefer-at-else": "error",
         "@angular-eslint/template/prefer-at-empty": "error",
         "@angular-eslint/template/prefer-contextual-for-variables": "error",
         "@angular-eslint/template/prefer-control-flow": "error",

package/dist/index.d.ts

@@ -28,6 +28,7 @@ declare const _default: {
                 "@angular-eslint/template/no-negated-async": string;
                 "@angular-eslint/template/no-nested-tags": string;
                 "@angular-eslint/template/no-positive-tabindex": string;
+                "@angular-eslint/template/prefer-at-else": string;
                 "@angular-eslint/template/prefer-at-empty": string;
                 "@angular-eslint/template/prefer-contextual-for-variables": string;
                 "@angular-eslint/template/prefer-control-flow": string;
@@ -112,6 +113,7 @@ declare const _default: {
         "no-negated-async": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-negated-async").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-nested-tags": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNestedTags", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-positive-tabindex": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-positive-tabindex").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "prefer-at-else": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAtElse", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-at-empty": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAtEmpty", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-contextual-for-variables": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-contextual-for-variables").MessageIds, import("./rules/prefer-contextual-for-variables").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-control-flow": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferControlFlow", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqGA,kBA6CE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,kBA8CE"}

package/dist/index.js

@@ -65,6 +65,7 @@ const no_negated_async_1 = __importStar(require("./rules/no-negated-async"));
 const no_nested_tags_1 = __importStar(require("./rules/no-nested-tags"));
 const no_positive_tabindex_1 = __importStar(require("./rules/no-positive-tabindex"));
 const prefer_ngsrc_1 = __importStar(require("./rules/prefer-ngsrc"));
+const prefer_at_else_1 = __importStar(require("./rules/prefer-at-else"));
 const prefer_at_empty_1 = __importStar(require("./rules/prefer-at-empty"));
 const prefer_contextual_for_variables_1 = __importStar(require("./rules/prefer-contextual-for-variables"));
 const prefer_control_flow_1 = __importStar(require("./rules/prefer-control-flow"));
@@ -108,6 +109,7 @@ module.exports = {
         [no_negated_async_1.RULE_NAME]: no_negated_async_1.default,
         [no_nested_tags_1.RULE_NAME]: no_nested_tags_1.default,
         [no_positive_tabindex_1.RULE_NAME]: no_positive_tabindex_1.default,
+        [prefer_at_else_1.RULE_NAME]: prefer_at_else_1.default,
         [prefer_at_empty_1.RULE_NAME]: prefer_at_empty_1.default,
         [prefer_contextual_for_variables_1.RULE_NAME]: prefer_contextual_for_variables_1.default,
         [prefer_control_flow_1.RULE_NAME]: prefer_control_flow_1.default,

package/dist/rules/prefer-at-else.d.ts

@@ -0,0 +1,6 @@
+export type Options = [];
+export type MessageIds = 'preferAtElse';
+export declare const RULE_NAME = "prefer-at-else";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAtElse", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-at-else.d.ts.map

package/dist/rules/prefer-at-else.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-at-else.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-at-else.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,cAAc,CAAC;AACxC,eAAO,MAAM,SAAS,mBAAmB,CAAC;;AAe1C,wBA+HG"}

package/dist/rules/prefer-at-else.js

@@ -0,0 +1,192 @@
+"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 are_equivalent_asts_1 = require("../utils/are-equivalent-asts");
+const ast_types_1 = require("../utils/ast-types");
+const to_range_1 = require("../utils/to-range");
+exports.RULE_NAME = 'prefer-at-else';
+const OPPOSITE_OPERATORS = new Map([
+    ['', '!'],
+    ['!', ''],
+    ['<', '>='],
+    ['>', '<='],
+    ['<=', '>'],
+    ['>=', '<'],
+    ['==', '!='],
+    ['!=', '=='],
+    ['===', '!=='],
+    ['!==', '==='],
+]);
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description: 'Prefer using `@else` instead of a second `@if` with the opposite condition to reduce code and make it easier to read.',
+        },
+        schema: [],
+        messages: {
+            preferAtElse: 'Prefer using `@else` instead of a second `@if` clause.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        const previousNodeStack = [undefined];
+        function getFix(previous, current) {
+            const previousIf = previous.node.branches[0];
+            const currentIf = current.node.branches[0];
+            const currentElse = current.node.branches.at(1);
+            const previousElse = previous.node.branches.at(1);
+            // If the current `@if` block uses an alias, then
+            // we won't fix it because the alias won't exist
+            // in the `@else` block of the previous `@if` block.
+            if (currentIf.expressionAlias) {
+                return null;
+            }
+            return function* fix(fixer) {
+                if (!previousElse) {
+                    // The previous `@if` block has no `@else` block,
+                    // so we can turn the current `@if` block into one.
+                    yield fixer.replaceTextRange([
+                        currentIf.sourceSpan.start.offset,
+                        currentIf.startSourceSpan.end.offset,
+                    ], '@else {');
+                }
+                else {
+                    // The previous `@if` block already has an `@else` block.
+                    // Since the current `@if` block is the opposite of the previous
+                    // `@if` block, the previous `@else` block and the current `@if`
+                    // block would both be rendered. We can achieve the same result
+                    // with a single block by putting the contents of the current
+                    // `@if` block at the end of the previous `@else` block.
+                    const ifContents = context.sourceCode.text.slice(currentIf.startSourceSpan.end.offset, currentIf.sourceSpan.end.offset - 1);
+                    yield fixer.insertTextAfterRange((0, to_range_1.toZeroLengthRange)(previousElse.sourceSpan.end.offset - 1), ifContents);
+                    yield fixer.removeRange((0, to_range_1.toRange)(currentIf.sourceSpan));
+                }
+                if (currentElse && currentIf.endSourceSpan) {
+                    // The current node has an `@else` block. Since the current
+                    // `@if` block is the opposite of the previous `@if` block,
+                    // the `@else` block would be rendered when the previous
+                    // `@if` is also rendered. We can achieve the same result
+                    // by putting the contents of the current `@else` block
+                    // at the end of the previous `@if` block.
+                    const elseContents = context.sourceCode.text.slice(currentElse.startSourceSpan.end.offset, currentElse.sourceSpan.end.offset - 1);
+                    yield fixer.insertTextAfterRange((0, to_range_1.toZeroLengthRange)(previousIf.sourceSpan.end.offset - 1), elseContents);
+                    yield fixer.removeRange([
+                        currentIf.endSourceSpan.end.offset,
+                        currentElse.sourceSpan.end.offset,
+                    ]);
+                }
+            };
+        }
+        return {
+            // We need to visit `@if` blocks, but we also
+            // need to know if there are any nodes immediately
+            // before them, so we need to visit all nodes.
+            '*'(node) {
+                const current = getIfNodeInfo(node);
+                if (current) {
+                    const previous = previousNodeStack.at(-1);
+                    if (previous && canCombine(previous, current)) {
+                        context.report({
+                            loc: parserServices.convertNodeSourceSpanToLoc(current.node.nameSpan),
+                            messageId: 'preferAtElse',
+                            fix: getFix(previous, current),
+                        });
+                    }
+                }
+                // Record this current node as the previous node so that
+                // we can get the info when we look at the next sibling.
+                previousNodeStack[previousNodeStack.length - 1] = current;
+                // We are about to visit the children of this node,
+                // so push a new "previous node info" onto the stack.
+                // The previous node of the first child is undefined.
+                previousNodeStack.push(undefined);
+            },
+            '*:exit'() {
+                // We've finished visiting the children of this node,
+                // so pop the "previous node info" off the stack.
+                previousNodeStack.pop();
+            },
+        };
+    },
+});
+function getIfNodeInfo(node) {
+    // We only care about `@if` blocks with one or two branches.
+    // Any more branches and it would have to contain an
+    // `@else if` branch, which we cannot handle.
+    if (node instanceof bundled_angular_compiler_1.TmplAstIfBlock &&
+        node.branches.length >= 1 &&
+        node.branches[0].expression instanceof bundled_angular_compiler_1.ASTWithSource &&
+        node.branches.length <= 2) {
+        // When there are two branches, the second
+        // branch cannot have an expression, otherwise it
+        // would be an `@else if` block, which we cannot
+        // combine with a previous or next `@if` block.
+        if (node.branches.length == 1 || !node.branches[1].expression) {
+            const ast = node.branches[0].expression.ast;
+            if (ast instanceof bundled_angular_compiler_1.Binary) {
+                return { node, lhs: ast.left, rhs: ast.right, operator: ast.operation };
+            }
+            if (ast instanceof bundled_angular_compiler_1.PrefixNot) {
+                return { node, lhs: ast.expression, rhs: undefined, operator: '!' };
+            }
+            return { node, lhs: ast, rhs: undefined, operator: '' };
+        }
+    }
+    return undefined;
+}
+function canCombine(previous, current) {
+    if (OPPOSITE_OPERATORS.get(previous.operator) === current.operator) {
+        if ((0, are_equivalent_asts_1.areEquivalentASTs)(previous.lhs, current.lhs)) {
+            if (previous.rhs === undefined && current.rhs === undefined) {
+                return true;
+            }
+            if (previous.rhs &&
+                current.rhs &&
+                (0, are_equivalent_asts_1.areEquivalentASTs)(previous.rhs, current.rhs)) {
+                return true;
+            }
+        }
+    }
+    // Arrays cannot have a length less than zero, so there is
+    // a special case we can look for. If the previous node
+    // was an "is empty" and the current node is "is not empty"
+    // (or vice versa), then we can consider them opposites.
+    if ((isEmptyLength(previous) && isNonEmptyLength(current)) ||
+        (isNonEmptyLength(previous) && isEmptyLength(current))) {
+        return true;
+    }
+    return false;
+}
+function isEmptyLength(node) {
+    if (node.rhs !== undefined) {
+        if (node.operator === '==' || node.operator === '===') {
+            if ((0, ast_types_1.isLengthRead)(node.lhs) && (0, ast_types_1.isZero)(node.rhs)) {
+                return true;
+            }
+            if ((0, ast_types_1.isZero)(node.lhs) && (0, ast_types_1.isLengthRead)(node.rhs)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isNonEmptyLength(node) {
+    if (node.rhs !== undefined) {
+        // We don't need to check for the inequality operators because
+        // they would be handled by the standard "are opposite" check.
+        if ((0, ast_types_1.isLengthRead)(node.lhs) && node.operator === '>' && (0, ast_types_1.isZero)(node.rhs)) {
+            return true;
+        }
+        if ((0, ast_types_1.isZero)(node.lhs) && node.operator === '<' && (0, ast_types_1.isLengthRead)(node.rhs)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/rules/prefer-at-empty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-at-empty.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-at-empty.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,eAAe,CAAC;AACzC,eAAO,MAAM,SAAS,oBAAoB,CAAC;;AAE3C,wBAwaG"}
+{"version":3,"file":"prefer-at-empty.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-at-empty.ts"],"names":[],"mappings":"AAiBA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,eAAe,CAAC;AACzC,eAAO,MAAM,SAAS,oBAAoB,CAAC;;AAE3C,wBAwaG"}

package/dist/rules/prefer-at-empty.js

@@ -5,6 +5,8 @@ const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-comp
 const utils_1 = require("@angular-eslint/utils");
 const create_eslint_rule_1 = require("../utils/create-eslint-rule");
 const are_equivalent_asts_1 = require("../utils/are-equivalent-asts");
+const ast_types_1 = require("../utils/ast-types");
+const to_range_1 = require("../utils/to-range");
 exports.RULE_NAME = 'prefer-at-empty';
 exports.default = (0, create_eslint_rule_1.createESLintRule)({
     name: exports.RULE_NAME,
@@ -64,7 +66,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                         fix: branchEnd
                             ? function* (fixer) {
                                 // Remove the entire `@if` block.
-                                yield fixer.removeRange(toRange(previous.node.sourceSpan));
+                                yield fixer.removeRange((0, to_range_1.toRange)(previous.node.sourceSpan));
                                 if (forInfo.node.empty) {
                                     // There is already an `@empty` block. The contents of the
                                     // `@if` block and the contents of the `@empty` block would
@@ -83,7 +85,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                                 else {
                                     // Take the contents of the `@if` block and move
                                     // it into an `@empty` block after the `@for` block.
-                                    yield fixer.insertTextAfterRange(toRange(forInfo.node.sourceSpan), ` @empty {${context.sourceCode.text.slice(branch.startSourceSpan.end.offset, branchEnd.end.offset)}`);
+                                    yield fixer.insertTextAfterRange((0, to_range_1.toRange)(forInfo.node.sourceSpan), ` @empty {${context.sourceCode.text.slice(branch.startSourceSpan.end.offset, branchEnd.end.offset)}`);
                                 }
                             }
                             : undefined,
@@ -115,14 +117,14 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                                     // the existing contents of the `@empty` block. This can
                                     // easily be achieved by removing the closing brace of the
                                     // `@empty` block and removing the `@if` statement.
-                                    yield fixer.removeRange(toRange(previous.node.empty.endSourceSpan));
-                                    yield fixer.removeRange(toRange(ifInfo.node.startSourceSpan));
+                                    yield fixer.removeRange((0, to_range_1.toRange)(previous.node.empty.endSourceSpan));
+                                    yield fixer.removeRange((0, to_range_1.toRange)(ifInfo.node.startSourceSpan));
                                 }
                                 else {
                                     // There is not already an `@empty` block, so
                                     // we can create one by replacing the entire
                                     // `@if (...) {` segment with `@empty {`.
-                                    yield fixer.replaceTextRange(toRange(ifInfo.node.startSourceSpan), '@empty {');
+                                    yield fixer.replaceTextRange((0, to_range_1.toRange)(ifInfo.node.startSourceSpan), '@empty {');
                                 }
                             },
                         });
@@ -143,16 +145,16 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                                 fix: previousIfBlockEnd
                                     ? (fixer) => [
                                         // Remove the previous `@if` statement.
-                                        fixer.removeRange(toRange(previous.node.startSourceSpan)),
+                                        fixer.removeRange((0, to_range_1.toRange)(previous.node.startSourceSpan)),
                                         // Remove the closing brace from the previous `@if` block.
-                                        fixer.removeRange(toRange(previousIfBlockEnd)),
+                                        fixer.removeRange((0, to_range_1.toRange)(previousIfBlockEnd)),
                                         // Take the contents of the current `@if` block and move
                                         // it into the `@empty` block of the previous `@for` block.
-                                        fixer.insertTextAfterRange(toRange(forBlock.sourceSpan), ` @empty {${context.sourceCode.text.slice(ifInfo.node.startSourceSpan.end.offset, 
+                                        fixer.insertTextAfterRange((0, to_range_1.toRange)(forBlock.sourceSpan), ` @empty {${context.sourceCode.text.slice(ifInfo.node.startSourceSpan.end.offset, 
                                         // The end offset includes the closing brace.
                                         ifInfo.node.sourceSpan.end.offset)}`),
                                         // Remove the entirety of the current `@if` block.
-                                        fixer.removeRange(toRange(ifInfo.node.sourceSpan)),
+                                        fixer.removeRange((0, to_range_1.toRange)(ifInfo.node.sourceSpan)),
                                     ]
                                     : undefined,
                             });
@@ -202,7 +204,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                                 // There isn't an existing `@empty` block, so we can create
                                 // one. We don't need to include a closing brace, because
                                 // we can reuse the one from the end of the @`if` block.
-                                yield fixer.insertTextAfterRange(toRange(forBlock.sourceSpan), ` @empty {${empty}`);
+                                yield fixer.insertTextAfterRange((0, to_range_1.toRange)(forBlock.sourceSpan), ` @empty {${empty}`);
                             }
                         }
                         : undefined,
@@ -223,12 +225,12 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                             messageId: 'preferAtEmpty',
                             fix: (fixer) => [
                                 // Remove the entire previous `@if` block.
-                                fixer.removeRange(toRange(previous.node.sourceSpan)),
+                                fixer.removeRange((0, to_range_1.toRange)(previous.node.sourceSpan)),
                                 // Remove the current `@if` statement.
-                                fixer.removeRange(toRange(ifNotInfo.node.startSourceSpan)),
+                                fixer.removeRange((0, to_range_1.toRange)(ifNotInfo.node.startSourceSpan)),
                                 // Take the contents of the previous `@if` block and move
                                 // it into the `@empty` block after the `@for` block.
-                                fixer.insertTextAfterRange(toRange(forBlock.sourceSpan), ` @empty {${context.sourceCode.text.slice(previous.node.startSourceSpan.end.offset, 
+                                fixer.insertTextAfterRange((0, to_range_1.toRange)(forBlock.sourceSpan), ` @empty {${context.sourceCode.text.slice(previous.node.startSourceSpan.end.offset, 
                                 // The end offset is after the closing `}`, so we
                                 // need to subtract one to ensure it gets removed.
                                 previous.node.sourceSpan.end.offset - 1)}`),
@@ -257,10 +259,10 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                                 // block, the `@empty` block would never be rendered,
                                 // so we can remove it. We could try to replace it,
                                 // but it's easier to remove it and create a new one.
-                                yield fixer.removeRange(toRange(forBlock.empty.sourceSpan));
+                                yield fixer.removeRange((0, to_range_1.toRange)(forBlock.empty.sourceSpan));
                             }
                             // Remove the entire `@if (...) {` segment.
-                            yield fixer.removeRange(toRange(info.node.startSourceSpan));
+                            yield fixer.removeRange((0, to_range_1.toRange)(info.node.startSourceSpan));
                             const elseBranch = info.node.branches[1];
                             if (elseBranch.expression) {
                                 // The second branch is an `@else if` branch. We
@@ -273,7 +275,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                                     ifBranchEnd.end.offset - 1,
                                     elseBranch.nameSpan.end.offset,
                                 ], '@empty { @if ');
-                                yield fixer.insertTextAfterRange(toRange(ifEnd), '}');
+                                yield fixer.insertTextAfterRange((0, to_range_1.toRange)(ifEnd), '}');
                             }
                             else {
                                 // The second branch is just an `@else` branch, so we
@@ -424,16 +426,16 @@ function getNotEmptyTestCollection(node) {
     if (node instanceof bundled_angular_compiler_1.ASTWithSource) {
         node = node.ast;
     }
-    if (isLengthRead(node)) {
+    if ((0, ast_types_1.isLengthRead)(node)) {
         // @if (collection.length)
         return node.receiver;
     }
     if (node instanceof bundled_angular_compiler_1.Binary) {
-        if (isLengthRead(node.left)) {
+        if ((0, ast_types_1.isLengthRead)(node.left)) {
             if (node.operation === '!==' ||
                 node.operation === '>' ||
                 node.operation === '!=') {
-                if (isZero(node.right)) {
+                if ((0, ast_types_1.isZero)(node.right)) {
                     // @if (collection.length !== 0)
                     // @if (collection.length > 0)
                     // @if (collection.length != 0)
@@ -441,11 +443,11 @@ function getNotEmptyTestCollection(node) {
                 }
             }
         }
-        else if (isZero(node.left)) {
+        else if ((0, ast_types_1.isZero)(node.left)) {
             if (node.operation === '!==' ||
                 node.operation === '<' ||
                 node.operation === '!=') {
-                if (isLengthRead(node.right)) {
+                if ((0, ast_types_1.isLengthRead)(node.right)) {
                     // @if (0 !== collection.length)
                     // @if (0 < collection.length)
                     // @if (0 != collection.length)
@@ -461,24 +463,24 @@ function getEmptyTestCollection(node) {
         node = node.ast;
     }
     if (node instanceof bundled_angular_compiler_1.PrefixNot) {
-        if (isLengthRead(node.expression)) {
+        if ((0, ast_types_1.isLengthRead)(node.expression)) {
             // @if (!collection.length)
             return node.expression.receiver;
         }
     }
     else if (node instanceof bundled_angular_compiler_1.Binary) {
-        if (isLengthRead(node.left)) {
+        if ((0, ast_types_1.isLengthRead)(node.left)) {
             if (node.operation === '===' || node.operation === '==') {
-                if (isZero(node.right)) {
+                if ((0, ast_types_1.isZero)(node.right)) {
                     // @if (collection.length === 0)
                     // @if (collection.length == 0)
                     return node.left.receiver;
                 }
             }
         }
-        else if (isZero(node.left)) {
+        else if ((0, ast_types_1.isZero)(node.left)) {
             if (node.operation === '===' || node.operation === '==') {
-                if (isLengthRead(node.right)) {
+                if ((0, ast_types_1.isLengthRead)(node.right)) {
                     // @if (0 === collection.length)
                     // @if (0 == collection.length)
                     return node.right.receiver;
@@ -488,12 +490,3 @@ function getEmptyTestCollection(node) {
     }
     return undefined;
 }
-function isLengthRead(node) {
-    return node instanceof bundled_angular_compiler_1.PropertyRead && node.name === 'length';
-}
-function isZero(node) {
-    return node instanceof bundled_angular_compiler_1.LiteralPrimitive && node.value === 0;
-}
-function toRange(span) {
-    return [span.start.offset, span.end.offset];
-}

package/dist/utils/ast-types.d.ts

@@ -0,0 +1,4 @@
+import { AST, PropertyRead } from '@angular-eslint/bundled-angular-compiler';
+export declare function isLengthRead(node: AST): node is PropertyRead;
+export declare function isZero(node: AST): boolean;
+//# sourceMappingURL=ast-types.d.ts.map

package/dist/utils/ast-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-types.d.ts","sourceRoot":"","sources":["../../src/utils/ast-types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EAEH,YAAY,EACb,MAAM,0CAA0C,CAAC;AAElD,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,IAAI,YAAY,CAE5D;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAEzC"}

package/dist/utils/ast-types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLengthRead = isLengthRead;
+exports.isZero = isZero;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+function isLengthRead(node) {
+    return node instanceof bundled_angular_compiler_1.PropertyRead && node.name === 'length';
+}
+function isZero(node) {
+    return node instanceof bundled_angular_compiler_1.LiteralPrimitive && node.value === 0;
+}

package/dist/utils/to-range.d.ts

@@ -0,0 +1,4 @@
+import { ParseSourceSpan } from '@angular-eslint/bundled-angular-compiler';
+export declare function toRange(span: ParseSourceSpan): [number, number];
+export declare function toZeroLengthRange(offset: number): [number, number];
+//# sourceMappingURL=to-range.d.ts.map

package/dist/utils/to-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-range.d.ts","sourceRoot":"","sources":["../../src/utils/to-range.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAE3E,wBAAgB,OAAO,CAAC,IAAI,EAAE,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAE/D;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAElE"}

package/dist/utils/to-range.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRange = toRange;
+exports.toZeroLengthRange = toZeroLengthRange;
+function toRange(span) {
+    return [span.start.offset, span.end.offset];
+}
+function toZeroLengthRange(offset) {
+    return [offset, offset];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin-template",
-  "version": "20.3.1-alpha.14",
+  "version": "20.3.1-alpha.15",
   "description": "ESLint plugin for Angular Templates",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,19 +20,19 @@
   "dependencies": {
     "aria-query": "5.3.2",
     "axobject-query": "4.1.0",
-    "@angular-eslint/bundled-angular-compiler": "20.3.1-alpha.14",
-    "@angular-eslint/utils": "20.3.1-alpha.14"
+    "@angular-eslint/bundled-angular-compiler": "20.3.1-alpha.15",
+    "@angular-eslint/utils": "20.3.1-alpha.15"
   },
   "devDependencies": {
     "@types/aria-query": "5.0.4",
-    "@angular-eslint/test-utils": "20.3.1-alpha.14"
+    "@angular-eslint/test-utils": "20.3.1-alpha.15"
   },
   "peerDependencies": {
     "@typescript-eslint/types": "^7.11.0 || ^8.0.0",
     "@typescript-eslint/utils": "^7.11.0 || ^8.0.0",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": "*",
-    "@angular-eslint/template-parser": "20.3.1-alpha.14"
+    "@angular-eslint/template-parser": "20.3.1-alpha.15"
   },
   "gitHead": "e2006e5e9c99e5a943d1a999e0efa5247d29ec24"
 }