@angular-eslint/eslint-plugin 21.2.1-alpha.1 → 21.2.1-alpha.2

package/README.md

@@ -21,6 +21,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 <!-- prettier-ignore-start -->
 | Rule | Description | :white_check_mark: | :wrench: | :bulb: |
 | --- | --- | --- | --- | --- |
+| [`computed-must-return`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/computed-must-return.md) | Ensures that computed() returns a value. Omitting the value is likely a mistake. |  |  |  |
 | [`contextual-lifecycle`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/contextual-lifecycle.md) | Ensures that lifecycle methods are used in a correct context | :white_check_mark: |  |  |
 | [`no-async-lifecycle-method`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-async-lifecycle-method.md) | Angular Lifecycle methods should not be async. Angular does not wait for async lifecycle but the code incorrectly suggests it does. |  |  |  |
 | [`no-attribute-decorator`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-attribute-decorator.md) | The @Attribute decorator is used to obtain a single value for an attribute. This is a much less common use case than getting a stream of values (using @Input), so the @Attribute decorator is often mistakenly used when @Input is intended. This rule disallows the usage of @Attribute decorator entirely to prevent these mistakes. |  |  |  |

package/dist/configs/all.json

@@ -5,6 +5,7 @@
     "@angular-eslint/component-class-suffix": "error",
     "@angular-eslint/component-max-inline-declarations": "error",
     "@angular-eslint/component-selector": "error",
+    "@angular-eslint/computed-must-return": "error",
     "@angular-eslint/consistent-component-styles": "error",
     "@angular-eslint/contextual-decorator": "error",
     "@angular-eslint/contextual-lifecycle": "error",

package/dist/index.d.ts

@@ -7,6 +7,7 @@ declare const _default: {
                 "@angular-eslint/component-class-suffix": string;
                 "@angular-eslint/component-max-inline-declarations": string;
                 "@angular-eslint/component-selector": string;
+                "@angular-eslint/computed-must-return": string;
                 "@angular-eslint/consistent-component-styles": string;
                 "@angular-eslint/contextual-decorator": string;
                 "@angular-eslint/contextual-lifecycle": string;
@@ -76,6 +77,7 @@ declare const _default: {
         "component-class-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"componentClassSuffix", import("./rules/component-class-suffix").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "component-max-inline-declarations": import("@typescript-eslint/utils/ts-eslint").RuleModule<"componentMaxInlineDeclarations", import("./rules/component-max-inline-declarations").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "component-selector": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/component-selector").MessageIds, import("./rules/component-selector").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "computed-must-return": import("@typescript-eslint/utils/ts-eslint").RuleModule<"computedMissingReturn", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "consistent-component-styles": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/consistent-component-styles").MessageIds, import("./rules/consistent-component-styles").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "contextual-decorator": import("@typescript-eslint/utils/ts-eslint").RuleModule<"contextualDecorator", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "contextual-lifecycle": import("@typescript-eslint/utils/ts-eslint").RuleModule<"contextualLifecycle", [], 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoJA,kBAwDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuJA,kBAyDE"}

package/dist/index.js

@@ -85,6 +85,7 @@ const use_pipe_transform_interface_1 = __importStar(require("./rules/use-pipe-tr
 const no_experimental_1 = __importStar(require("./rules/no-experimental"));
 const no_developer_preview_1 = __importStar(require("./rules/no-developer-preview"));
 const no_implicit_take_until_destroyed_1 = __importStar(require("./rules/no-implicit-take-until-destroyed"));
+const computed_must_return_1 = __importStar(require("./rules/computed-must-return"));
 module.exports = {
     configs: {
         all: all_json_1.default,
@@ -94,6 +95,7 @@ module.exports = {
         [component_class_suffix_1.RULE_NAME]: component_class_suffix_1.default,
         [component_max_inline_declarations_1.RULE_NAME]: component_max_inline_declarations_1.default,
         [component_selector_1.RULE_NAME]: component_selector_1.default,
+        [computed_must_return_1.RULE_NAME]: computed_must_return_1.default,
         [consistent_component_styles_1.RULE_NAME]: consistent_component_styles_1.default,
         [contextual_decorator_1.RULE_NAME]: contextual_decorator_1.default,
         [contextual_lifecycle_1.RULE_NAME]: contextual_lifecycle_1.default,

package/dist/rules/computed-must-return.d.ts

@@ -0,0 +1,9 @@
+export type Options = [];
+export type MessageIds = 'computedMissingReturn';
+export declare const RULE_NAME = "computed-must-return";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"computedMissingReturn", [], 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=computed-must-return.d.ts.map

package/dist/rules/computed-must-return.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed-must-return.d.ts","sourceRoot":"","sources":["../../src/rules/computed-must-return.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,uBAAuB,CAAC;AACjD,eAAO,MAAM,SAAS,yBAAyB,CAAC;;AAEhD,wBAqEG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/computed-must-return.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const utils_1 = require("@typescript-eslint/utils");
+exports.RULE_NAME = 'computed-must-return';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Ensures that computed() returns a value. Omitting the value is likely a mistake.`,
+        },
+        schema: [],
+        messages: {
+            computedMissingReturn: 'computed() is missing a return value',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const functionStack = [];
+        function enterFunction(node) {
+            functionStack.push({
+                node,
+                hasReturn: false,
+            });
+        }
+        function exitFunction(node) {
+            const funcInfo = functionStack.pop();
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                node.parent.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.parent.callee.name === 'computed' &&
+                node.parent.arguments[0] === node) {
+                // Arrow function without a body
+                if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                    node.expression) {
+                    return;
+                }
+                if (!funcInfo?.hasReturn) {
+                    context.report({
+                        node: node.parent,
+                        messageId: 'computedMissingReturn',
+                    });
+                }
+            }
+        }
+        return {
+            ArrowFunctionExpression: enterFunction,
+            'ArrowFunctionExpression:exit': exitFunction,
+            FunctionExpression: enterFunction,
+            'FunctionExpression:exit': exitFunction,
+            ReturnStatement(node) {
+                if (node.argument && functionStack.length > 0) {
+                    functionStack[functionStack.length - 1].hasReturn = true;
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "`computed()` is used to transform signal values. If no value is returned from `computed()`, it's likely a mistake.",
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "21.2.1-alpha.1",
+  "version": "21.2.1-alpha.2",
   "description": "ESLint plugin for Angular applications, following https://angular.dev/style-guide",
   "license": "MIT",
   "main": "dist/index.js",
@@ -19,11 +19,11 @@
   ],
   "dependencies": {
     "ts-api-utils": "^2.1.0",
-    "@angular-eslint/bundled-angular-compiler": "21.2.1-alpha.1",
-    "@angular-eslint/utils": "21.2.1-alpha.1"
+    "@angular-eslint/bundled-angular-compiler": "21.2.1-alpha.2",
+    "@angular-eslint/utils": "21.2.1-alpha.2"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "21.2.1-alpha.1"
+    "@angular-eslint/test-utils": "21.2.1-alpha.2"
   },
   "peerDependencies": {
     "@typescript-eslint/utils": "^7.11.0 || ^8.0.0",