@angular-eslint/eslint-plugin-template 20.4.1-alpha.0 → 20.4.1-alpha.1

package/README.md

@@ -65,6 +65,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`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-built-in-pipes`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-built-in-pipes.md) | Encourages the use of Angular built-in pipes (e.g. lowercase, uppercase, titlecase) instead of certain JavaScript methods in Angular templates. |  |  |  |  |
 | [`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. |  |  |  |  |
 | [`prefer-ngsrc`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-ngsrc.md) | Ensures ngSrc is used instead of src for img elements |  |  |  |  |

package/dist/configs/all.json

@@ -28,6 +28,7 @@
     "@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-built-in-pipes": "error",
     "@angular-eslint/template/prefer-contextual-for-variables": "error",
     "@angular-eslint/template/prefer-control-flow": "error",
     "@angular-eslint/template/prefer-ngsrc": "error",

package/dist/index.d.ts

@@ -30,6 +30,7 @@ declare const _default: {
                 "@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-built-in-pipes": string;
                 "@angular-eslint/template/prefer-contextual-for-variables": string;
                 "@angular-eslint/template/prefer-control-flow": string;
                 "@angular-eslint/template/prefer-ngsrc": string;
@@ -105,6 +106,7 @@ declare const _default: {
         "no-any": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-any").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-autofocus": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noAutofocus", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "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>;
+        "prefer-built-in-pipes": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferBuiltInPipes", import("./rules/prefer-built-in-pipes").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-empty-control-flow": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noEmptyControlFlow", [], 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,kBA8CE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2GA,kBA+CE"}

package/dist/index.js

@@ -56,6 +56,7 @@ const mouse_events_have_key_events_1 = __importStar(require("./rules/mouse-event
 const no_any_1 = __importStar(require("./rules/no-any"));
 const no_autofocus_1 = __importStar(require("./rules/no-autofocus"));
 const no_call_expression_1 = __importStar(require("./rules/no-call-expression"));
+const prefer_built_in_pipes_1 = __importStar(require("./rules/prefer-built-in-pipes"));
 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"));
@@ -101,6 +102,7 @@ module.exports = {
         [no_any_1.RULE_NAME]: no_any_1.default,
         [no_autofocus_1.RULE_NAME]: no_autofocus_1.default,
         [no_call_expression_1.RULE_NAME]: no_call_expression_1.default,
+        [prefer_built_in_pipes_1.RULE_NAME]: prefer_built_in_pipes_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_empty_control_flow_1.RULE_NAME]: no_empty_control_flow_1.default,

package/dist/rules/no-call-expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-call-expression.d.ts","sourceRoot":"","sources":["../../src/rules/no-call-expression.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACvC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;KAC/B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC;AAC5C,eAAO,MAAM,SAAS,uBAAuB,CAAC;;AAE9C,wBA4EG"}
+{"version":3,"file":"no-call-expression.d.ts","sourceRoot":"","sources":["../../src/rules/no-call-expression.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACvC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;KAC/B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC;AAC5C,eAAO,MAAM,SAAS,uBAAuB,CAAC;;AAE9C,wBA4EG"}

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

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RULE_NAME = void 0;
-const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
 const utils_1 = require("@angular-eslint/utils");
 const create_eslint_rule_1 = require("../utils/create-eslint-rule");
 const get_nearest_node_from_1 = require("../utils/get-nearest-node-from");
+const is_bound_event_1 = require("../utils/is-bound-event");
+const is_ast_with_name_1 = require("../utils/is-ast-with-name");
 exports.RULE_NAME = 'no-call-expression';
 exports.default = (0, create_eslint_rule_1.createESLintRule)({
     name: exports.RULE_NAME,
@@ -40,18 +41,18 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         const sourceCode = context.sourceCode;
         return {
             'Call[receiver.name!="$any"]'(node) {
-                const isChildOfBoundEvent = Boolean((0, get_nearest_node_from_1.getNearestNodeFrom)(node, isBoundEvent));
+                const isChildOfBoundEvent = Boolean((0, get_nearest_node_from_1.getNearestNodeFrom)(node, is_bound_event_1.isBoundEvent));
                 if (isChildOfBoundEvent ||
                     isCallNameInAllowList(node.receiver, allowList)) {
                     return;
                 }
                 if (allowPrefix &&
-                    isASTWithName(node.receiver) &&
+                    (0, is_ast_with_name_1.isASTWithName)(node.receiver) &&
                     node.receiver.name.startsWith(allowPrefix)) {
                     return;
                 }
                 if (allowSuffix &&
-                    isASTWithName(node.receiver) &&
+                    (0, is_ast_with_name_1.isASTWithName)(node.receiver) &&
                     node.receiver.name.endsWith(allowSuffix)) {
                     return;
                 }
@@ -67,15 +68,9 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         };
     },
 });
-function isBoundEvent(node) {
-    return node instanceof bundled_angular_compiler_1.TmplAstBoundEvent;
-}
-function isASTWithName(ast) {
-    return !!ast.name;
-}
 function isCallNameInAllowList(ast, allowList) {
     return (allowList &&
         allowList.length > 0 &&
-        isASTWithName(ast) &&
+        (0, is_ast_with_name_1.isASTWithName)(ast) &&
         allowList.indexOf(ast.name) > -1);
 }

package/dist/rules/prefer-built-in-pipes.d.ts

@@ -0,0 +1,11 @@
+export type Options = [
+    {
+        readonly disallowList?: readonly string[];
+        readonly allowInOutputHandlers?: boolean;
+    }
+];
+export type MessageIds = 'preferBuiltInPipes';
+export declare const RULE_NAME = "prefer-built-in-pipes";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferBuiltInPipes", Options, import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-built-in-pipes.d.ts.map

package/dist/rules/prefer-built-in-pipes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-built-in-pipes.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-built-in-pipes.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC1C,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,CAAC;KAC1C;CACF,CAAC;AASF,MAAM,MAAM,UAAU,GAAG,oBAAoB,CAAC;AAC9C,eAAO,MAAM,SAAS,0BAA0B,CAAC;;AAEjD,wBA6EG"}

package/dist/rules/prefer-built-in-pipes.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const get_nearest_node_from_1 = require("../utils/get-nearest-node-from");
+const is_bound_event_1 = require("../utils/is-bound-event");
+const is_ast_with_name_1 = require("../utils/is-ast-with-name");
+const DEFAULT_DISALLOW_LIST = [
+    'toLowerCase',
+    'toUpperCase',
+    'toLocaleLowerCase',
+    'toLocaleUpperCase',
+];
+exports.RULE_NAME = 'prefer-built-in-pipes';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Encourages the use of Angular built-in pipes (e.g. lowercase, uppercase, titlecase) instead of certain JavaScript methods in Angular templates.',
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    disallowList: {
+                        items: { type: 'string' },
+                        type: 'array',
+                        uniqueItems: true,
+                        description: 'Additional method names to disallow (defaults include common case/title casing helpers)',
+                    },
+                    allowInOutputHandlers: {
+                        type: 'boolean',
+                        description: 'Whether to allow these method calls inside output event handlers',
+                    },
+                },
+                type: 'object',
+            },
+        ],
+        messages: {
+            preferBuiltInPipes: 'Avoid using method "{{ methodName }}" in templates. Prefer the Angular built-in pipes instead (e.g. lowercase, uppercase, titlecase).',
+        },
+    },
+    defaultOptions: [
+        {
+            disallowList: [...DEFAULT_DISALLOW_LIST],
+            allowInOutputHandlers: true,
+        },
+    ],
+    create(context, [{ disallowList, allowInOutputHandlers }]) {
+        (0, utils_1.ensureTemplateParser)(context);
+        const sourceCode = context.sourceCode;
+        const methodsToDisallow = disallowList || [...DEFAULT_DISALLOW_LIST];
+        return {
+            Call(node) {
+                if (!isDisallowedMethod(node.receiver, methodsToDisallow)) {
+                    return;
+                }
+                if (allowInOutputHandlers) {
+                    const isChildOfBoundEvent = Boolean((0, get_nearest_node_from_1.getNearestNodeFrom)(node, is_bound_event_1.isBoundEvent));
+                    if (isChildOfBoundEvent) {
+                        return;
+                    }
+                }
+                const methodName = getMethodName(node.receiver);
+                const { sourceSpan: { start, end }, } = node.receiver;
+                context.report({
+                    loc: {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end),
+                    },
+                    messageId: 'preferBuiltInPipes',
+                    data: {
+                        methodName,
+                    },
+                });
+            },
+        };
+    },
+});
+function isDisallowedMethod(ast, disallowList) {
+    return ((0, is_ast_with_name_1.isASTWithName)(ast) &&
+        ast instanceof bundled_angular_compiler_1.PropertyRead &&
+        disallowList.includes(ast.name));
+}
+function getMethodName(ast) {
+    return (0, is_ast_with_name_1.isASTWithName)(ast) ? ast.name : 'unknown';
+}

package/dist/utils/is-ast-with-name.d.ts

@@ -0,0 +1,10 @@
+import type { AST } from '@angular-eslint/bundled-angular-compiler';
+/**
+ * Type guard to check if an AST node has a name property
+ */
+export declare function isASTWithName(ast: AST & {
+    name?: string;
+}): ast is AST & {
+    name: string;
+};
+//# sourceMappingURL=is-ast-with-name.d.ts.map

package/dist/utils/is-ast-with-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-ast-with-name.d.ts","sourceRoot":"","sources":["../../src/utils/is-ast-with-name.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,0CAA0C,CAAC;AAEpE;;GAEG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,GAAG,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3B,GAAG,IAAI,GAAG,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAE/B"}

package/dist/utils/is-ast-with-name.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isASTWithName = isASTWithName;
+/**
+ * Type guard to check if an AST node has a name property
+ */
+function isASTWithName(ast) {
+    return !!ast.name;
+}

package/dist/utils/is-bound-event.d.ts

@@ -0,0 +1,6 @@
+import { TmplAstBoundEvent } from '@angular-eslint/bundled-angular-compiler';
+/**
+ * Type guard to check if a node is a TmplAstBoundEvent (output event handler)
+ */
+export declare function isBoundEvent(node: unknown): node is TmplAstBoundEvent;
+//# sourceMappingURL=is-bound-event.d.ts.map

package/dist/utils/is-bound-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-bound-event.d.ts","sourceRoot":"","sources":["../../src/utils/is-bound-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAE7E;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,iBAAiB,CAErE"}

package/dist/utils/is-bound-event.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBoundEvent = isBoundEvent;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+/**
+ * Type guard to check if a node is a TmplAstBoundEvent (output event handler)
+ */
+function isBoundEvent(node) {
+    return node instanceof bundled_angular_compiler_1.TmplAstBoundEvent;
+}

package/package.json

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