update

Author: zhangfisher

docs/zh/store/guide/store/config.md

@@ -625,12 +625,12 @@ const netStore = new AutoStore(
         dhcp: true,
         ip: configurable("192.168.1.1", {
             label: "IP地址",
-            enable: (scope: any) => {
-                // ❗ scope===AutoStoreConfigManager.state
-                // ❗ 而dhcp并没有声明为可配置项
-                // ❗ 因此AutoStoreConfigManager.state不存在network.dhcp
-                // ❗ enable是在AutoStoreConfigManager
-                // ❗ dhcp是在netStore，两者并不在同一个Store中
+            enable: (scope: any, { refStore }) => {
+                //❗ scope===AutoStoreConfigManager.state
+                //❗ 而dhcp并没有声明为可配置项
+                //❗ 因此AutoStoreConfigManager.state不存在network.dhcp
+                //❗ enable是在AutoStoreConfigManager
+                //❗ dhcp是在netStore，两者并不在同一个Store中
                 return scope["network.dhcp"].value; // [!code ++] ❌无效
             },
         }),

packages/core/__tests__/ip.ts

@@ -14,21 +14,19 @@ configManager.watch(({ path, value }) => {
 });
 const netStore = new AutoStore(
     {
-        dhcp: configurable(true, {
-            label: "自动获取IP地址",
-        }),
+        dhcp: true,
         ip: configurable("192.168.1.1", {
             label: "IP地址",
-            enable: (scope: any) => {
+            enable: (scope: any, { ref }) => {
                 return scope["network.dhcp"].value;
             },
         }),
     },
     { configManager, id: "network" },
 );
 netStore.state.dhcp = true;
-console.log(configManager.state["network.dhcp"].value);
+// console.log(configManager.state["network.dhcp"].value);
 console.log(configManager.state["network.ip"].enable);
 netStore.state.dhcp = false;
-console.log(configManager.state["network.dhcp"].value);
+// console.log(configManager.state["network.dhcp"].value);
 console.log(configManager.state["network.ip"].enable);

packages/core/src/computed/async.ts

@@ -325,6 +325,7 @@ export class AsyncComputedObject<Value = any, Scope = any> extends ComputedObjec
             operate: options.operate,
             first: options.first,
             abortSignal: abortController.signal,
+            ref: () => undefined as any,
         };
 
         const ctx: GetterRunContext = {

packages/core/src/computed/types.ts

@@ -25,6 +25,7 @@ import type {
 import type { StateOperate } from "../store/types";
 import type { ComputedObject } from "./computedObject";
 import type { Dict } from "../types";
+import { RefState } from "../store/refState";
 
 /**
  * 同步计算属性配置参数
@@ -95,6 +96,7 @@ export interface AsyncComputedGetterArgs {
      * 是否是第一次运行
      */
     first?: boolean;
+    ref?: <Value = any>(path: string | string[]) => Value;
 }
 
 export type AsyncComputedGetter<Value, Scope = any> = (

packages/core/src/observer/observer.ts

@@ -17,6 +17,7 @@ import type { StateOperate, StoreEvents, UpdateOptions } from "../store/types";
 import type { Watcher, WatchListenerOptions } from "../watch/types";
 import { calcDependPaths } from "../utils/calcDependPaths";
 import { isFunction } from "flex-tools/typecheck/isFunction";
+import { createRefState, RefState } from "../store/refState";
 
 export class ObserverObject<
     Value = any,
@@ -36,6 +37,7 @@ export class ObserverObject<
     private _error?: Error; // 记录最后一次运行时的错误
     store: AutoStore<any>;
     _shadowStore!: AutoStore<any>;
+    _refState?: RefState;
     /**
      *  构造函数。
      *
@@ -172,6 +174,16 @@ export class ObserverObject<
         }
         this.onInitial();
     }
+    private _createRefState() {
+        // @ts-expect-error
+        const _getRefStore = this.descriptor.getter._getRefStore;
+        if (isFunction(_getRefStore)) {
+            const storeRef = _getRefStore() as WeakRef<AutoStore<any>>;
+            if (storeRef) {
+                this._refState = createRefState(storeRef, this as ObserverObject);
+            }
+        }
+    }
     /**
      * 供子类继承进行初始化
      */

packages/core/src/schema/manager.ts

@@ -1,6 +1,6 @@
 import { PATH_DELIMITER, GLOBAL_CONFIG_MANAGER } from "../consts";
 import { AutoStore } from "../store/store";
-import { isSchemaBuilder, markRaw, setVal, withSchema } from "../utils";
+import { isRaw, isSchemaBuilder, markRaw, setVal, withSchema } from "../utils";
 import { getVal } from "../utils/getVal";
 import type { SchemaDescriptor, SchemaDescriptorBuilder, AutoStoreConfigures } from "./types";
 import { isFunction } from "../utils/isFunction";
@@ -230,6 +230,33 @@ export class ConfigManager extends AutoStore<
         if ((descriptor.schema as any).onInvalid === undefined) {
             (descriptor.schema as any).onInvalid = "throw";
         }
+        // 安装校验器
+        this._installValidator(strPath, descriptor, store);
+        // 由于该配置项可能已先load还未注册，因此需要覆盖现有的值
+        const loadedValue = this.peep((state) =>
+            getVal(state, [configKey.join(PATH_DELIMITER), "value"]),
+        );
+        // 用于为schema中的observerObject提供refStore，以便能访问
+        this._handleRefState(descriptor.schema, store);
+        // 动态添加
+        this.state[configKey.join(PATH_DELIMITER)] = descriptor.schema;
+        if (loadedValue !== undefined) {
+            descriptor.schema.value = loadedValue;
+        }
+        // 创建代理用于从原始的Store值读写状态值
+        this._createValueProxy(descriptor, store, pathKey);
+
+        // 返回初始值，避免读取代理导致循环依赖
+        return loadedValue || initialValue;
+    }
+    private _handleRefState(schema: object, store: AutoStore<any>) {
+        Object.values(schema).forEach((v) => {
+            if (isFunction(v) && !isRaw(v)) {
+                v._getRefStore = () => new WeakRef(store);
+            }
+        });
+    }
+    private _installValidator(path: string, descriptor: SchemaDescriptor, store: AutoStore<any>) {
         if (isFunction(descriptor.schema.validate)) {
             // 将getErrorMessage 方法和validationBehavior添加到验证函数上，用于在isValidPass中使用
             // @ts-expect-error
@@ -252,34 +279,19 @@ export class ConfigManager extends AutoStore<
             if (!store.options.validators) {
                 store.options.validators = {};
             }
-            store.options.validators[strPath] = descriptor.schema.validate;
+            store.options.validators[path] = descriptor.schema.validate;
         } else {
             if (store.options.validators) {
-                delete store.options.validators[strPath];
+                delete store.options.validators[path];
             }
         }
-        // 由于该配置项可能已先load还未注册，因此需要覆盖现有的值
-        const loadedValue = this.peep((state) =>
-            getVal(state, [configKey.join(PATH_DELIMITER), "value"]),
-        );
-
-        // 动态添加
-        this.state[configKey.join(PATH_DELIMITER)] = descriptor.schema;
-        if (loadedValue !== undefined) {
-            descriptor.schema.value = loadedValue;
-        }
-
-        // 创建代理用于从原始的Store值读写状态值
-        this._createValueProxy(descriptor, store, pathKey);
-
-        // 返回初始值，避免读取代理导致循环依赖
-        return loadedValue || initialValue;
     }
     private _createValueProxy(
         finalDescriptor: SchemaDescriptor,
         store: AutoStore<any>,
         path: string[],
     ) {
+        // oxlint-disable-next-line typescript/no-this-alias
         const self = this;
 
         // 由于ConfigManager是全局对象，而Store可能是动态，可能会被销毁，因此应采用弱引用

packages/core/src/store/refState.ts

@@ -0,0 +1,33 @@
+import { ObserverObject } from "../observer";
+import { AutoStore } from "./store";
+import type { Dict } from "../types";
+import { getVal } from "../utils/getVal";
+import { Watcher } from "../watch/types";
+
+export type RefState = {
+    off: () => void;
+    ref: <Value = any>(path: string | string[]) => Value | undefined;
+};
+
+export function createRefState(
+    storeRef: WeakRef<AutoStore<any>>,
+    observerObj: ObserverObject,
+): RefState {
+    let watcher: Watcher | null = null;
+    return {
+        ref: <Value = any>(path: string | string[], args?: Record<string, any>) => {
+            const store = storeRef.deref();
+            if (store) {
+                if (!watcher) {
+                    watcher = store.watch(path, () => {
+                        observerObj.run(args);
+                    });
+                }
+                return getVal(store.state, path) as Value;
+            }
+        },
+        off: () => {
+            watcher?.off();
+        },
+    };
+}

packages/core/src/types/index.ts

@@ -77,7 +77,6 @@ export type PickComputedResult<T> =
 如：ComputedState<{count:async ()=>1}> => {count:number}
 
 */
-
 export type ComputedState<T> = T extends unknown[]
     ? ComputedState<T[number]>[]
     : T extends RawObject<T>