@angular-eslint/eslint-plugin-template 21.2.1-alpha.2 → 21.2.1-alpha.3

package/README.md

@@ -62,6 +62,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`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: |  |
+| [`no-non-null-assertion`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-non-null-assertion.md) | Disallows the non-null assertion operator (!) in templates |  |  |  |  |
 | [`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: |  |  |

package/dist/configs/all.json

@@ -25,6 +25,7 @@
     "@angular-eslint/template/no-interpolation-in-attributes": "error",
     "@angular-eslint/template/no-negated-async": "error",
     "@angular-eslint/template/no-nested-tags": "error",
+    "@angular-eslint/template/no-non-null-assertion": "error",
     "@angular-eslint/template/no-positive-tabindex": "error",
     "@angular-eslint/template/prefer-at-else": "error",
     "@angular-eslint/template/prefer-at-empty": "error",

package/dist/index.d.ts

@@ -27,6 +27,7 @@ declare const _default: {
                 "@angular-eslint/template/no-interpolation-in-attributes": string;
                 "@angular-eslint/template/no-negated-async": string;
                 "@angular-eslint/template/no-nested-tags": string;
+                "@angular-eslint/template/no-non-null-assertion": string;
                 "@angular-eslint/template/no-positive-tabindex": string;
                 "@angular-eslint/template/prefer-at-else": string;
                 "@angular-eslint/template/prefer-at-empty": string;
@@ -116,6 +117,7 @@ declare const _default: {
         "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-non-null-assertion": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNonNullAssertion", [], 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>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8GA,kBAgDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiHA,kBAiDE"}

package/dist/index.js

@@ -64,6 +64,7 @@ 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"));
 const no_nested_tags_1 = __importStar(require("./rules/no-nested-tags"));
+const no_non_null_assertion_1 = __importStar(require("./rules/no-non-null-assertion"));
 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"));
@@ -111,6 +112,7 @@ module.exports = {
         [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_non_null_assertion_1.RULE_NAME]: no_non_null_assertion_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,

package/dist/rules/no-any.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-any.d.ts","sourceRoot":"","sources":["../../src/rules/no-any.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,kBAAkB,CAAC;AACtD,eAAO,MAAM,SAAS,WAAW,CAAC;;AAGlC,wBA0FG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}
+{"version":3,"file":"no-any.d.ts","sourceRoot":"","sources":["../../src/rules/no-any.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,kBAAkB,CAAC;AACtD,eAAO,MAAM,SAAS,WAAW,CAAC;;AAGlC,wBAuFG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/no-any.js

@@ -78,9 +78,6 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                 }
                 reportAnyCall(node);
             },
-            KeyedRead(node) {
-                findAndReportAnyCalls(node);
-            },
         };
     },
 });

package/dist/rules/no-non-null-assertion.d.ts

@@ -0,0 +1,9 @@
+export type Options = [];
+export type MessageIds = 'noNonNullAssertion';
+export declare const RULE_NAME = "no-non-null-assertion";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNonNullAssertion", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=no-non-null-assertion.d.ts.map

package/dist/rules/no-non-null-assertion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-non-null-assertion.d.ts","sourceRoot":"","sources":["../../src/rules/no-non-null-assertion.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,oBAAoB,CAAC;AAC9C,eAAO,MAAM,SAAS,0BAA0B,CAAC;;AAEjD,wBAgCG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/no-non-null-assertion.js

@@ -0,0 +1,39 @@
+"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-non-null-assertion';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallows the non-null assertion operator (!) in templates',
+        },
+        schema: [],
+        messages: {
+            noNonNullAssertion: 'Avoid using the non-null assertion operator (!) in templates. This bypasses type safety and can lead to runtime errors.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        (0, utils_1.ensureTemplateParser)(context);
+        const { sourceCode } = context;
+        return {
+            NonNullAssert(node) {
+                const { start, end } = node.sourceSpan;
+                context.report({
+                    messageId: 'noNonNullAssertion',
+                    loc: {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end),
+                    },
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Equivalent of @typescript-eslint/no-non-null-assertion rule for Angular templates. TypeScript's `!` non-null assertion operator asserts to the type system that an expression is non-nullable, as in not `null` or `undefined`. Using assertions to tell the type system new information is often a sign that code is not fully type-safe. It's generally better to structure program logic so that TypeScript understands when values may be nullable.",
+};

package/package.json

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