amis-core 6.11.0-beta.1 → 6.11.0-beta.2

package/lib/store/root.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.1
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 
@@ -18,7 +18,7 @@ require('../utils/columnsSplit.js');
 var object = require('../utils/object.js');
 require('../utils/memoryParse.js');
 require('amis-formula');
-require('lodash/isPlainObject');
+var isPlainObject = require('lodash/isPlainObject');
 require('../utils/DataSchema.js');
 require('../utils/DataScope.js');
 require('moment');
@@ -36,7 +36,7 @@ require('../utils/icon.js');
 require('../utils/image.js');
 require('lodash/isEqual');
 require('../actions/Action.js');
-require('lodash/debounce');
+var debounce = require('lodash/debounce');
 require('../utils/resize-sensor.js');
 require('react');
 require('react-overlays/useRootClose');
@@ -54,24 +54,70 @@ require('../utils/validations.js');
 require('../utils/resolveCondition.js');
 require('mobx');
 require('../utils/Animation.js');
+var globalVar = require('../globalVar.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isPlainObject__default = /*#__PURE__*/_interopDefaultLegacy(isPlainObject);
+var debounce__default = /*#__PURE__*/_interopDefaultLegacy(debounce);
 
 var RootStore = service.ServiceStore.named('RootStore')
     .props({
     runtimeError: mobxStateTree.types.frozen(),
     runtimeErrorStack: mobxStateTree.types.frozen(),
     query: mobxStateTree.types.frozen(),
-    ready: false
+    ready: false,
+    globalVarStates: mobxStateTree.types.optional(mobxStateTree.types.map(mobxStateTree.types.frozen()), {})
 })
     .volatile(function (self) {
     return {
-        context: {}
+        context: {},
+        globalVars: [],
+        globalData: {
+            global: {},
+            globalState: {}
+        }
     };
 })
     .views(function (self) { return ({
     get downStream() {
         var result = self.data;
-        if (self.context || self.query) {
+        if (self.context || self.query || self.globalVarStates.size) {
             var chain = object.extractObjectChain(result);
+            // 数据链中添加 global 和 globalState
+            // 对应的是全局变量的值和全局变量的状态
+            if (self.globalVarStates.size) {
+                var globalData_1 = {};
+                var touched_1 = false;
+                var saved_1 = true;
+                var errors_1 = {};
+                var initialized_1 = true;
+                self.globalVarStates.forEach(function (state, key) {
+                    globalData_1[key] = state.value;
+                    touched_1 = touched_1 || state.touched;
+                    if (!state.saved) {
+                        saved_1 = false;
+                    }
+                    if (state.errorMessages.length) {
+                        errors_1[key] = state.errorMessages;
+                    }
+                    if (!state.initialized) {
+                        initialized_1 = false;
+                    }
+                });
+                // 保存全局变量的值和状态
+                Object.assign(self.globalData.global, globalData_1);
+                Object.assign(self.globalData.globalState, {
+                    fields: self.globalVarStates.toJSON(),
+                    initialized: initialized_1,
+                    touched: touched_1,
+                    saved: saved_1,
+                    errors: errors_1,
+                    valid: !Object.keys(errors_1).length
+                });
+                // self.globalData 一直都是那个对象，这样组件里面始终拿到的都是最新的
+                chain.unshift(self.globalData);
+            }
             self.context && chain.unshift(self.context);
             self.query &&
                 chain.splice(chain.length - 1, 0, tslib.__assign(tslib.__assign({}, self.query), { __query: self.query }));
@@ -81,32 +127,459 @@ var RootStore = service.ServiceStore.named('RootStore')
     }
 }); })
     .actions(function (self) {
+    function updateState(key, state) {
+        return self.updateGlobalVarState(key, state);
+    }
     var init = mobxStateTree.flow(function init(fn) {
-        var ret;
+        var ret, e_1;
         return tslib.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    _a.trys.push([0, , 3, 4]);
+                    _a.trys.push([0, 3, 4, 5]);
                     ret = fn();
                     if (!(ret === null || ret === void 0 ? void 0 : ret.then)) return [3 /*break*/, 2];
                     return [4 /*yield*/, ret];
                 case 1:
                     _a.sent();
                     _a.label = 2;
-                case 2: return [3 /*break*/, 4];
+                case 2: return [3 /*break*/, 5];
                 case 3:
+                    e_1 = _a.sent();
+                    self.runtimeError = e_1.message;
+                    self.runtimeErrorStack = e_1.stack;
+                    return [3 /*break*/, 5];
+                case 4:
                     self.ready = true;
                     return [7 /*endfinally*/];
-                case 4: return [2 /*return*/];
+                case 5: return [2 /*return*/];
             }
         });
     });
+    /**
+     * 比较新旧变量列表的差异
+     * @param vars 新的变量列表
+     * @param originVars 原始变量列表
+     * @returns 返回新增、更新和删除的变量列表
+     */
+    function diffVariables(vars, originVars) {
+        var e_2, _a;
+        var removeVars = originVars.concat();
+        var updateVars = [];
+        var newVars = [];
+        var _loop_1 = function (varItem) {
+            var idx = removeVars.findIndex(function (item) { return item.key === varItem.key; });
+            if (~idx) {
+                var _b = tslib.__read(removeVars.splice(idx, 1), 1), origin_1 = _b[0];
+                if (origin_1.id !== varItem.id) {
+                    updateVars.push(varItem);
+                }
+            }
+            else {
+                newVars.push(varItem);
+            }
+        };
+        try {
+            for (var vars_1 = tslib.__values(vars), vars_1_1 = vars_1.next(); !vars_1_1.done; vars_1_1 = vars_1.next()) {
+                var varItem = vars_1_1.value;
+                _loop_1(varItem);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (vars_1_1 && !vars_1_1.done && (_a = vars_1.return)) _a.call(vars_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return {
+            newVars: newVars,
+            updateVars: updateVars,
+            removeVars: removeVars
+        };
+    }
+    /**
+     * 初始化单个全局变量
+     */
+    function initGlobalVarData(item, context, getter) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var value, state;
+            return tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        value = item.defaultValue;
+                        if (!getter) return [3 /*break*/, 2];
+                        return [4 /*yield*/, getGlobalVarData(item, context, getter)];
+                    case 1:
+                        _a.sent();
+                        state = self.globalVarStates.get(item.key);
+                        updateState(item.key, {
+                            initialized: true,
+                            pristine: state.value
+                        });
+                        return [3 /*break*/, 3];
+                    case 2:
+                        updateState(item.key, {
+                            value: value,
+                            pristine: value,
+                            initialized: item.bulkGetter ? false : true
+                        });
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    /**
+     * 批量初始化全局变量
+     */
+    function getGlobalVarData(item, context, getter) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var value;
+            return tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, , 2, 3]);
+                        updateState(item.key, {
+                            busy: true
+                        });
+                        return [4 /*yield*/, getter(item, context)];
+                    case 1:
+                        value = _a.sent();
+                        updateState(item.key, {
+                            value: value
+                        });
+                        return [3 /*break*/, 3];
+                    case 2:
+                        updateState(item.key, {
+                            busy: false
+                        });
+                        return [7 /*endfinally*/];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    /**
+     * 批量初始化全局变量
+     */
+    function bulkGetGlobalVarData(variables, context, getter) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var data, _loop_2, key;
+            return tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, , 2, 3]);
+                        variables.forEach(function (item) {
+                            updateState(item.key, {
+                                busy: true
+                            });
+                        });
+                        return [4 /*yield*/, getter.call(null, tslib.__assign(tslib.__assign({}, context), { variables: variables }))];
+                    case 1:
+                        data = _a.sent();
+                        if (!isPlainObject__default["default"](data)) {
+                            return [2 /*return*/];
+                        }
+                        _loop_2 = function (key) {
+                            // 返回非定义部分的数据不处理
+                            if (!variables.some(function (item) { return item.key === key; })) {
+                                return "continue";
+                            }
+                            var state = self.globalVarStates.get(key);
+                            if (state) {
+                                updateState(key, {
+                                    value: data[key],
+                                    pristine: data[key],
+                                    initialized: true
+                                });
+                            }
+                        };
+                        for (key in data) {
+                            _loop_2(key);
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        variables.forEach(function (item) {
+                            updateState(item.key, {
+                                busy: false
+                            });
+                        });
+                        return [7 /*endfinally*/];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    /**
+     * 初始化全局变量
+     */
+    function initializeGlobalVars(newVars, updateVars) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var variables, context, globalVars, bulkGetters, itemsNotInitialized, _loop_3, globalVars_1, globalVars_1_1, item;
+            var e_3, _a;
+            return tslib.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        variables = newVars.concat(updateVars);
+                        context = tslib.__assign(tslib.__assign({}, self.context), { variables: variables });
+                        globalVars = variables.map(function (item) {
+                            return globalVar.buildGlobalVariable(item, context);
+                        });
+                        bulkGetters = [];
+                        itemsNotInitialized = [];
+                        _loop_3 = function (item) {
+                            var state = self.globalVarStates.get(item.key);
+                            if (state === null || state === void 0 ? void 0 : state.initialized) {
+                                return "continue";
+                            }
+                            itemsNotInitialized.push(item);
+                            if (item.bulkGetter) {
+                                var getter = bulkGetters.find(function (a) { return a.fn === item.bulkGetter; });
+                                if (!getter) {
+                                    getter = {
+                                        fn: item.bulkGetter,
+                                        variables: []
+                                    };
+                                    bulkGetters.push(getter);
+                                }
+                                getter.variables.push(item);
+                            }
+                        };
+                        try {
+                            for (globalVars_1 = tslib.__values(globalVars), globalVars_1_1 = globalVars_1.next(); !globalVars_1_1.done; globalVars_1_1 = globalVars_1.next()) {
+                                item = globalVars_1_1.value;
+                                _loop_3(item);
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (globalVars_1_1 && !globalVars_1_1.done && (_a = globalVars_1.return)) _a.call(globalVars_1);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                        // 先单个初始化
+                        return [4 /*yield*/, Promise.all(itemsNotInitialized.map(function (item) {
+                                return initGlobalVarData(item, context, item.getter);
+                            }))];
+                    case 1:
+                        // 先单个初始化
+                        _b.sent();
+                        // 再批量初始化
+                        return [4 /*yield*/, Promise.all(bulkGetters.map(function (_a) {
+                                var fn = _a.fn, variables = _a.variables;
+                                return bulkGetGlobalVarData(variables, context, fn);
+                            }))];
+                    case 2:
+                        // 再批量初始化
+                        _b.sent();
+                        return [2 /*return*/, globalVars];
+                }
+            });
+        });
+    }
+    // 设置全局变量,返回一个Promise
+    var setGlobalVars = mobxStateTree.flow(function setGlobalVars(vars) {
+        var _a, newVars, updateVars, removeVars, _b;
+        return tslib.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _a = diffVariables(vars || [], self.globalVars), newVars = _a.newVars, updateVars = _a.updateVars, removeVars = _a.removeVars;
+                    // 初始化全局变量
+                    _b = self;
+                    return [4 /*yield*/, initializeGlobalVars(newVars, updateVars)];
+                case 1:
+                    // 初始化全局变量
+                    _b.globalVars = _c.sent();
+                    removeVars.forEach(function (item) {
+                        self.globalVarStates.delete(item.key);
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    });
+    // 更新全局变量的值
+    var updateGlobalVarValue = function (key, value) {
+        return modifyGlobalVarValue(key, { op: 'set', value: value });
+    };
+    // 如果对应变量是个对象，那么可以通过这个扩充变量的值
+    var modifyGlobalVarValue = function (key, options) {
+        var state = self.globalVarStates.get(key);
+        if (!state) {
+            return;
+        }
+        var value = state.value;
+        switch (options.op) {
+            case 'set':
+                value = options.value;
+                break;
+        }
+        updateState(key, {
+            value: value,
+            touched: true
+        });
+        lazySaveGlobalVarValues();
+    };
+    /**
+     * 保存单个全局变量的值
+     */
+    function saveGlobalVarData(item, value, context, setter) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            return tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, , 2, 3]);
+                        updateState(item.key, {
+                            busy: true
+                        });
+                        return [4 /*yield*/, setter(item, value, context)];
+                    case 1:
+                        _a.sent();
+                        updateState(item.key, {
+                            saved: true
+                        });
+                        return [3 /*break*/, 3];
+                    case 2:
+                        updateState(item.key, {
+                            busy: false
+                        });
+                        return [7 /*endfinally*/];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    /**
+     * 批量保存全局变量
+     */
+    function bulkSaveGlobalVarData(variables, values, context, setter) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            return tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, , 2, 3]);
+                        variables.forEach(function (item) {
+                            updateState(item.key, {
+                                busy: true
+                            });
+                        });
+                        return [4 /*yield*/, setter(values, tslib.__assign(tslib.__assign({}, context), { variables: variables }))];
+                    case 1:
+                        _a.sent();
+                        variables.forEach(function (item) {
+                            updateState(item.key, {
+                                saved: true
+                            });
+                        });
+                        return [3 /*break*/, 3];
+                    case 2:
+                        variables.forEach(function (item) {
+                            updateState(item.key, {
+                                busy: false
+                            });
+                        });
+                        return [7 /*endfinally*/];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    /**
+     * 保存全局变量的值
+     */
+    function saveGlobalVarValues(key) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var context, setters, bulkSetters, values, _loop_4, _a, _b, varItem;
+            var e_4, _c;
+            return tslib.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        context = tslib.__assign(tslib.__assign({}, self.context), { variables: self.globalVars });
+                        setters = [];
+                        bulkSetters = [];
+                        values = {};
+                        _loop_4 = function (varItem) {
+                            var state = self.globalVarStates.get(varItem.key);
+                            if (!(state === null || state === void 0 ? void 0 : state.touched)) {
+                                return "continue";
+                            }
+                            else if (key && key !== varItem.key) {
+                                return "continue";
+                            }
+                            else if (!key && varItem.autoSave === false) {
+                                return "continue";
+                            }
+                            values[varItem.key] = state.value;
+                            if (varItem.setter) {
+                                setters.push({
+                                    fn: varItem.setter,
+                                    item: varItem,
+                                    value: state.value
+                                });
+                            }
+                            if (varItem.bulkSetter) {
+                                var setter = bulkSetters.find(function (a) { return a.fn === varItem.bulkSetter; });
+                                if (!setter) {
+                                    setter = {
+                                        fn: varItem.bulkSetter,
+                                        variables: [],
+                                        values: {}
+                                    };
+                                    bulkSetters.push(setter);
+                                }
+                                setter.variables.push(varItem);
+                                setter.values[varItem.key] = state.value;
+                            }
+                        };
+                        try {
+                            for (_a = tslib.__values(self.globalVars), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                varItem = _b.value;
+                                _loop_4(varItem);
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        return [4 /*yield*/, Promise.all(setters
+                                .map(function (_a) {
+                                var fn = _a.fn, item = _a.item, value = _a.value;
+                                return saveGlobalVarData(item, value, context, fn);
+                            })
+                                .concat(bulkSetters.map(function (_a) {
+                                var variables = _a.variables, values = _a.values, fn = _a.fn;
+                                return bulkSaveGlobalVarData(variables, values, context, fn);
+                            })))];
+                    case 1:
+                        _d.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    // 延迟保存全局变量的值
+    var lazySaveGlobalVarValues = debounce__default["default"](saveGlobalVarValues, 250, {
+        trailing: true,
+        leading: false
+    });
     return {
         updateContext: function (context) {
             // 因为 context 不是受控属性，直接共用引用好了
             // 否则还会触发孩子节点的重新渲染
             Object.assign(self.context, context);
         },
+        updateGlobalVarState: function (key, state) {
+            var origin = self.globalVarStates.get(key);
+            var newState = tslib.__assign(tslib.__assign({}, (origin || globalVar.createGlobalVarState())), state);
+            self.globalVarStates.set(key, newState);
+        },
+        setGlobalVars: setGlobalVars,
+        updateGlobalVarValue: updateGlobalVarValue,
+        modifyGlobalVarValue: modifyGlobalVarValue,
+        saveGlobalVarValues: lazySaveGlobalVarValues,
         setRuntimeError: function (error, errorStack) {
             self.runtimeError = error;
             self.runtimeErrorStack = errorStack;
@@ -117,7 +590,10 @@ var RootStore = service.ServiceStore.named('RootStore')
                 self.query = query;
             }
         },
-        init: init
+        init: init,
+        afterDestroy: function () {
+            lazySaveGlobalVarValues.flush();
+        }
     };
 });
 

package/lib/store/service.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.1
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/lib/store/status.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.1
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */