@angular-eslint/eslint-plugin-template 20.1.2-alpha.9 → 20.2.0

package/README.md

@@ -58,6 +58,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`no-autofocus`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-autofocus.md) | [Accessibility] Ensures that the `autofocus` attribute is not used |  | :wrench: |  | :accessibility: |
 | [`no-call-expression`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-call-expression.md) | Disallows calling expressions in templates, except for output handlers |  |  |  |  |
 | [`no-distracting-elements`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-distracting-elements.md) | [Accessibility] Enforces that no distracting elements are used |  | :wrench: |  | :accessibility: |
+| [`no-empty-control-flow`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-empty-control-flow.md) | Ensures that control flow blocks are not empty. Empty control flow blocks usually occur due to refactoring that wasn't completed. They can cause confusion when reading code. |  |  |  |  |
 | [`no-inline-styles`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-inline-styles.md) | Disallows the use of inline styles in HTML templates |  |  |  |  |
 | [`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: |  |

package/dist/configs/all.json

@@ -20,6 +20,7 @@
     "@angular-eslint/template/no-call-expression": "error",
     "@angular-eslint/template/no-distracting-elements": "error",
     "@angular-eslint/template/no-duplicate-attributes": "error",
+    "@angular-eslint/template/no-empty-control-flow": "error",
     "@angular-eslint/template/no-inline-styles": "error",
     "@angular-eslint/template/no-interpolation-in-attributes": "error",
     "@angular-eslint/template/no-negated-async": "error",

package/dist/index.d.ts

@@ -22,6 +22,7 @@ declare const _default: {
                 "@angular-eslint/template/no-call-expression": string;
                 "@angular-eslint/template/no-distracting-elements": string;
                 "@angular-eslint/template/no-duplicate-attributes": string;
+                "@angular-eslint/template/no-empty-control-flow": string;
                 "@angular-eslint/template/no-inline-styles": string;
                 "@angular-eslint/template/no-interpolation-in-attributes": string;
                 "@angular-eslint/template/no-negated-async": string;
@@ -105,17 +106,18 @@ declare const _default: {
         "no-call-expression": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noCallExpression", import("./rules/no-call-expression").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-distracting-elements": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noDistractingElements", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-duplicate-attributes": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-duplicate-attributes").MessageIds, import("./rules/no-duplicate-attributes").Options, 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-empty-control-flow": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noEmptyControlFlow", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-inline-styles": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInlineStyles", import("./rules/no-inline-styles").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-interpolation-in-attributes": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInterpolationInAttributes", import("./rules/no-interpolation-in-attributes").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "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-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>;
+        "prefer-ngsrc": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-ngsrc").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-self-closing-tags": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSelfClosingTags", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-static-string-properties": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferStaticStringProperties", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        "prefer-ngsrc": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-ngsrc").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-template-literal": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferTemplateLiteral", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "role-has-required-aria": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/role-has-required-aria").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "table-scope": import("@typescript-eslint/utils/ts-eslint").RuleModule<"tableScope", [], 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkGA,kBA4CE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqGA,kBA6CE"}

package/dist/index.js

@@ -58,6 +58,7 @@ const no_autofocus_1 = __importStar(require("./rules/no-autofocus"));
 const no_call_expression_1 = __importStar(require("./rules/no-call-expression"));
 const no_distracting_elements_1 = __importStar(require("./rules/no-distracting-elements"));
 const no_duplicate_attributes_1 = __importStar(require("./rules/no-duplicate-attributes"));
+const no_empty_control_flow_1 = __importStar(require("./rules/no-empty-control-flow"));
 const no_inline_styles_1 = __importStar(require("./rules/no-inline-styles"));
 const no_interpolation_in_attributes_1 = __importStar(require("./rules/no-interpolation-in-attributes"));
 const no_negated_async_1 = __importStar(require("./rules/no-negated-async"));
@@ -101,17 +102,18 @@ module.exports = {
         [no_call_expression_1.RULE_NAME]: no_call_expression_1.default,
         [no_distracting_elements_1.RULE_NAME]: no_distracting_elements_1.default,
         [no_duplicate_attributes_1.RULE_NAME]: no_duplicate_attributes_1.default,
-        [no_nested_tags_1.RULE_NAME]: no_nested_tags_1.default,
+        [no_empty_control_flow_1.RULE_NAME]: no_empty_control_flow_1.default,
         [no_inline_styles_1.RULE_NAME]: no_inline_styles_1.default,
         [no_interpolation_in_attributes_1.RULE_NAME]: no_interpolation_in_attributes_1.default,
         [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_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,
+        [prefer_ngsrc_1.RULE_NAME]: prefer_ngsrc_1.default,
         [prefer_self_closing_tags_1.RULE_NAME]: prefer_self_closing_tags_1.default,
         [prefer_static_string_properties_1.RULE_NAME]: prefer_static_string_properties_1.default,
-        [prefer_ngsrc_1.RULE_NAME]: prefer_ngsrc_1.default,
         [prefer_template_literal_1.RULE_NAME]: prefer_template_literal_1.default,
         [role_has_required_aria_1.RULE_NAME]: role_has_required_aria_1.default,
         [table_scope_1.RULE_NAME]: table_scope_1.default,

package/dist/rules/conditional-complexity.js

@@ -39,7 +39,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                 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 possibleBinary = extractPossibleBinaryOrConditionalFrom(getParser().parseBinding(node.value.source, node.valueSpan, 0).ast);
                 const totalComplexity = getTotalComplexity(possibleBinary);
                 if (totalComplexity <= maxComplexity) {
                     return;

package/dist/rules/no-empty-control-flow.d.ts

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

package/dist/rules/no-empty-control-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-empty-control-flow.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-control-flow.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,oBAAoB,CAAC;AAC9C,eAAO,MAAM,SAAS,0BAA0B,CAAC;;AAEjD,wBA0EG"}

package/dist/rules/no-empty-control-flow.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 create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-empty-control-flow';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: "Ensures that control flow blocks are not empty. Empty control flow blocks usually occur due to refactoring that wasn't completed. They can cause confusion when reading code.",
+        },
+        schema: [],
+        messages: {
+            noEmptyControlFlow: 'Unexpected empty control flow block.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        return {
+            'ForLoopBlockEmpty,IfBlockBranch,SwitchBlockCase'(node) {
+                if (node.children.length === 0 ||
+                    isEmpty(node.startSourceSpan.end, node.endSourceSpan?.start)) {
+                    report(node);
+                }
+            },
+            ForLoopBlock(node) {
+                if (node.children.length === 0 ||
+                    // Like other block nodes, the start source span covers the opening
+                    // `@for (...) {` part, but the end source span is the closing `}`
+                    // at the end of the entire block, which might be after the `@empty {`
+                    // part. The main block span ends at the `}` that ends the content of
+                    // the `@for` block before the `@empty` block. Because it includes
+                    // the closing brace, we need to move it back by one.
+                    isEmpty(node.startSourceSpan.end, node.mainBlockSpan.end.moveBy(-1))) {
+                    report(node);
+                }
+            },
+            SwitchBlock(node) {
+                // A switch block is pointless without cases, so
+                // if there are no cases, don't bother checking
+                // if there's non-whitespace characters within it.
+                if (node.cases.length === 0) {
+                    report(node);
+                }
+            },
+        };
+        function isEmpty(contentStart, contentEnd) {
+            return (!!contentEnd &&
+                context.sourceCode.text
+                    .slice(contentStart.offset, contentEnd.offset)
+                    .trim() === '');
+        }
+        function report(node) {
+            context.report({
+                messageId: 'noEmptyControlFlow',
+                loc: parserServices.convertNodeSourceSpanToLoc(node.nameSpan),
+            });
+        }
+    },
+});

package/dist/rules/prefer-contextual-for-variables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-contextual-for-variables.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-contextual-for-variables.ts"],"names":[],"mappings":"AAoBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,cAAc,CAAC,EAAE;YACxB,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC3B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC3B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC3B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC1B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC1B,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;SAC1B,CAAC;KACH;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAClB,0BAA0B,GAC1B,aAAa,GACb,aAAa,GACb,YAAY,GACZ,YAAY,GACZ,WAAW,CAAC;AAChB,eAAO,MAAM,SAAS,oCAAoC,CAAC;;AAc3D,wBAiaG"}
+{"version":3,"file":"prefer-contextual-for-variables.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-contextual-for-variables.ts"],"names":[],"mappings":"AAoBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,cAAc,CAAC,EAAE;YACxB,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC3B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC3B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC3B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC1B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC1B,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;SAC1B,CAAC;KACH;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAClB,0BAA0B,GAC1B,aAAa,GACb,aAAa,GACb,YAAY,GACZ,YAAY,GACZ,WAAW,CAAC;AAChB,eAAO,MAAM,SAAS,oCAAoC,CAAC;;AAc3D,wBAkaG"}

package/dist/rules/prefer-contextual-for-variables.js

@@ -66,6 +66,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                                 description: 'Aliases for $odd that are allowed to be used.',
                             },
                         },
+                        additionalProperties: false,
                     },
                 },
                 additionalProperties: false,

package/dist/utils/are-equivalent-asts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"are-equivalent-asts.d.ts","sourceRoot":"","sources":["../../src/utils/are-equivalent-asts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EAuBJ,MAAM,0CAA0C,CAAC;AAElD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CA4JzD"}
+{"version":3,"file":"are-equivalent-asts.d.ts","sourceRoot":"","sources":["../../src/utils/are-equivalent-asts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EAqBJ,MAAM,0CAA0C,CAAC;AAElD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CA4IzD"}

package/dist/utils/are-equivalent-asts.js

@@ -94,16 +94,6 @@ function areEquivalentASTs(a, b) {
     if (a instanceof bundled_angular_compiler_1.Chain && b instanceof bundled_angular_compiler_1.Chain) {
         return areEquivalentASTArrays(a.expressions, b.expressions);
     }
-    if (a instanceof bundled_angular_compiler_1.PropertyWrite && b instanceof bundled_angular_compiler_1.PropertyWrite) {
-        return (a.name === b.name &&
-            areEquivalentASTs(a.receiver, b.receiver) &&
-            areEquivalentASTs(a.value, b.value));
-    }
-    if (a instanceof bundled_angular_compiler_1.KeyedWrite && b instanceof bundled_angular_compiler_1.KeyedWrite) {
-        return (areEquivalentASTs(a.key, b.key) &&
-            areEquivalentASTs(a.receiver, b.receiver) &&
-            areEquivalentASTs(a.value, b.value));
-    }
     if (a instanceof bundled_angular_compiler_1.TypeofExpression && b instanceof bundled_angular_compiler_1.TypeofExpression) {
         return areEquivalentASTs(a.expression, b.expression);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin-template",
-  "version": "20.1.2-alpha.9",
+  "version": "20.2.0",
   "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.1.2-alpha.9",
-    "@angular-eslint/utils": "20.1.2-alpha.9"
+    "@angular-eslint/bundled-angular-compiler": "20.2.0",
+    "@angular-eslint/utils": "20.2.0"
   },
   "devDependencies": {
     "@types/aria-query": "5.0.4",
-    "@angular-eslint/test-utils": "20.1.2-alpha.9"
+    "@angular-eslint/test-utils": "20.2.0"
   },
   "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.1.2-alpha.9"
+    "@angular-eslint/template-parser": "20.2.0"
   },
   "gitHead": "e2006e5e9c99e5a943d1a999e0efa5247d29ec24"
 }