update

zhangfisher · zhangfisher · commit 80ac008c5ad4 · 2026-02-02T11:36:51.000+08:00
diff --git a/packages/core/src/computed/async.ts b/packages/core/src/computed/async.ts
@@ -36,6 +36,13 @@ export class AsyncComputedObject<Value = any, Scope = any> extends ComputedObjec
     private _defaultAbortController: AbortController | null = null;
     private _userAbortController?: AbortController;
     private _firstRun: boolean = false; // 是否已经第一次运行过
+    /**
+     * 用于标识这是一个简单计算对象
+     *
+     * 不同于全功能异步计算对象
+     *
+     */
+    lite: boolean = false;
     get async() {
         return true;
     }
diff --git a/packages/core/src/computed/computedObject.ts b/packages/core/src/computed/computedObject.ts
@@ -43,6 +43,28 @@ export class ComputedObject<
     get val(): Value {
         return this.async ? (this.value as any).value : this.value;
     }
+    /**
+     * 报告计算状态
+     * @param name
+     * @param value
+     */
+    protected _reportComputedStatus(name: "loading" | "error", value: any) {
+        // @ts-ignore
+        if (!this[`_${name}`]) {
+            const reports: Record<string, any> = this.options.reports || {};
+            const path = reports[name];
+            if (Array.isArray(path) && path.length > 0) {
+                // @ts-ignore
+                this[`_${name}`] = getAbsolutePath(path, this.path);
+            }
+        } // @ts-ignore
+        if (Array.isArray(this[`_${name}`])) {
+            this.store.update((state) => {
+                // @ts-ignore
+                setVal(state, this[`_${name}`]!, value);
+            });
+        }
+    }
     /**
      * 检查计算函数是否被禁用
      *
diff --git a/packages/core/src/computed/liteAsync.ts b/packages/core/src/computed/liteAsync.ts
@@ -1,29 +1,26 @@
 /**
  *
- * 异步计算
- *
- *
+ * 轻量异步计算
  *
+ * 计算结果直接写入到原地
  *
+ * 没有进度条、超时、可中止、倒计时、重试等高级功能
  *
  */
-import { getAbsolutePath, isPathEq, setVal } from "../utils";
+import { isPathEq } from "../utils";
 import { getValueScope } from "../scope";
 import { ComputedObject } from "./computedObject";
 import { getSnap } from "../utils/getSnap";
 import type { StateOperate } from "../store/types";
-import {
-    AsyncLiteComputedGetterArgs,
-    LiteAsyncComputedOptions,
-    RuntimeComputedOptions,
-} from "./types";
+import { AsyncLiteComputedGetterArgs, ComputedOptions, RuntimeComputedOptions } from "./types";
 
 export class AsyncLiteComputedObject<Value = any, Scope = any> extends ComputedObject<
     Value,
-    LiteAsyncComputedOptions
+    ComputedOptions
 > {
     private _isRunning: boolean = false;
     private _firstRun: boolean = false; // 是否已经第一次运行过
+    lite: boolean = true; // 标识这是一个简单计算对象
     get async() {
         return true;
     }
@@ -100,23 +97,6 @@ export class AsyncLiteComputedObject<Value = any, Scope = any> extends ComputedO
             this._isRunning = false;
         }
     }
-    private _updateComputeContext(name: "loading" | "error", value: any) {
-        // @ts-ignore
-        if (!this[`_${name}`]) {
-            // @ts-ignore
-            const path = this.options[`${name}Path`];
-            if (Array.isArray(path) && path.length > 0) {
-                // @ts-ignore
-                this[`_${name}`] = getAbsolutePath(path, this.path);
-            }
-        } // @ts-ignore
-        if (Array.isArray(this[`_${name}`])) {
-            this.store.update((state) => {
-                // @ts-ignore
-                setVal(state, this[`_${name}`]!, value);
-            });
-        }
-    }
     /**
      * 执行计算函数
      *
@@ -133,41 +113,38 @@ export class AsyncLiteComputedObject<Value = any, Scope = any> extends ComputedO
         let computedResult: any;
 
         try {
-            try {
-                //
-                this._updateComputeContext("loading", true);
-                // 执行计算函数
-                computedResult = await this.getter.call(this, scope, getterArgs);
-                this.store.peep(() => {
-                    this.value = computedResult; // 将结果回写入store,且不触发get事件
-                });
-                this._updateComputeContext("error", undefined);
-            } catch (e: any) {
-                hasError = e;
-                this._updateComputeContext("error", e.message);
-            } finally {
-                this._updateComputeContext("loading", false);
-            }
-            // 计算完成后触发事件
-            if (hasError) {
-                this.error = hasError;
-                this.emitStoreEvent("computed:error", {
-                    path: this.path,
-                    id: this.id,
-                    error: hasError,
-                    computedObject: this,
-                });
-            } else {
-                this.emitStoreEvent("computed:done", {
-                    path: this.path,
-                    id: this.id,
-                    value: computedResult,
-                    computedObject: this,
-                });
-            }
-            this.onDoneCallback(options, computedResult, scope, computedResult);
+            //
+            this._reportComputedStatus("loading", true);
+            // 执行计算函数
+            computedResult = await this.getter.call(this, scope, getterArgs);
+            this.store.peep(() => {
+                this.value = computedResult; // 将结果回写入store,且不触发get事件
+            });
+            this._reportComputedStatus("error", undefined);
+        } catch (e: any) {
+            hasError = e;
+            this._reportComputedStatus("error", e.message);
         } finally {
+            this._reportComputedStatus("loading", false);
+        }
+        // 计算完成后触发事件
+        if (hasError) {
+            this.error = hasError;
+            this.emitStoreEvent("computed:error", {
+                path: this.path,
+                id: this.id,
+                error: hasError,
+                computedObject: this,
+            });
+        } else {
+            this.emitStoreEvent("computed:done", {
+                path: this.path,
+                id: this.id,
+                value: computedResult,
+                computedObject: this,
+            });
         }
+        this.onDoneCallback(options, computedResult, scope, computedResult);
     }
 
     /**
diff --git a/packages/core/src/computed/types.ts b/packages/core/src/computed/types.ts
@@ -263,6 +263,24 @@ export interface ComputedOptions<
         scope: Scope;
         value: any;
     }): void;
+    /**
+     * 在计算前后向指定路径的状态写入额外值
+     *
+     */
+    reports?: {
+        /**
+         * 在计算前后向loading指定状态写入true/false用于反馈
+         *
+         * 如loading=["./loading"]，则在开始计算前往当前计算属性所在的对象的loading=true
+         *  计算完成后置loading=false
+         *
+         */
+        loading?: string | string[];
+        /**
+         * 在计算出错时向指定路径写入错误信息
+         */
+        error?: string | string[];
+    };
 }
 
 export type AsyncComputedValue<Value = any> = {
@@ -330,24 +348,6 @@ export type SyncComputedDescriptorBuilder<Value = any, Scope = any> = ObserverDe
 
 // 简单异步计算
 
-export interface LiteAsyncComputedOptions {
-    /**
-     * 当开始执行异步计算时用于指定在此处写入true
-     * 执行完成后写入false
-     *
-     *
-     * 支持相对路径写法，
-     * loadingPath: ['./loading'] 代表在当前同一对象的loading写入
-     *
-     */
-    loadingPath?: string[] | string;
-    /**
-     * 当执行异步计算出错时在此处写入错误信息
-     *  支持相对路径写法，
-     */
-    errorPath?: string[] | string;
-}
-
 export interface AsyncLiteComputedGetterArgs {
     /**
      * 提供一个函数用来获取当前Scope的快照
@@ -367,22 +367,24 @@ export interface AsyncLiteComputedGetterArgs {
      */
     first?: boolean;
 }
+
 export type AsyncLiteComputedGetter<Value, Scope = any> = (
     scope: Scope,
     args: Required<AsyncLiteComputedGetterArgs>,
 ) => Promise<Value>;
+
 export type AsyncLiteComputedDescriptor<Value = any, Scope = any> = ObserverDescriptor<
     "computed",
     Value,
     Scope,
     AsyncLiteComputedGetter<Value, Scope>,
-    LiteAsyncComputedOptions & ComputedOptions<Value, Scope>
+    ComputedOptions<Value, Scope>
 >;
 
 export type AsyncLiteComputedDescriptorBuilder<
     Value = any,
     Scope = any,
-> = ObserverDescriptorBuilder<"computed", Value, Scope, AsyncComputedDescriptor<Value, Scope>>;
+> = ObserverDescriptorBuilder<"computed", Value, Scope, AsyncLiteComputedDescriptor<Value, Scope>>;
 
 // 全功能异步计算
 export type AsyncComputedDescriptor<Value = any, Scope = any> = ObserverDescriptor<
@@ -402,17 +404,22 @@ export type AsyncComputedDescriptorBuilder<Value = any, Scope = any> = ObserverD
 
 export type ComputedDescriptor<Value = any, Scope = any> =
     | SyncComputedDescriptor<Value, Scope>
+    | AsyncLiteComputedDescriptor<Value, Scope>
     | AsyncComputedDescriptor<Value, Scope>;
+
 export type ComputedDescriptorBuilder<Value = any, Scope = any> =
     | SyncComputedDescriptorBuilder<Value, Scope>
+    | AsyncLiteComputedDescriptorBuilder<Value, Scope>
     | AsyncComputedDescriptorBuilder<Value, Scope>;
 
 export type ComputedDescriptorParameter<Value = any, Scope = any> =
     | ComputedDescriptorBuilder<Value, Scope>
     | ComputedGetter<Value, Scope>
-    | AsyncComputedGetter<Value, Scope>;
+    | AsyncComputedGetter<Value, Scope>
+    | AsyncLiteComputedGetter<Value, Scope>;
 
 export type ComputedBuilder<Value, Scope> =
     | ComputedDescriptorBuilder<Value, Scope>
     | AsyncComputedGetter<Value, Scope>
+    | AsyncLiteComputedGetter<Value, Scope>
     | ComputedGetter<Value, Scope>;
