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

package/esm/store/root.js

@@ -1,9 +1,9 @@
 /**
- * amis-core v6.11.0-beta.0
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 
-import { __assign, __generator } from 'tslib';
+import { __assign, __generator, __values, __awaiter, __read } from 'tslib';
 import { types, flow } from 'mobx-state-tree';
 import { parseQuery, isObjectShallowModified } from '../utils/helper.js';
 import { ServiceStore } from './service.js';
@@ -15,7 +15,7 @@ import 'lodash/chunk';
 import { extractObjectChain, createObjectFromChain } from '../utils/object.js';
 import '../utils/memoryParse.js';
 import 'amis-formula';
-import 'lodash/isPlainObject';
+import isPlainObject from 'lodash/isPlainObject';
 import '../utils/DataSchema.js';
 import '../utils/DataScope.js';
 import 'moment';
@@ -31,7 +31,7 @@ import '@rc-component/mini-decimal';
 import '../utils/image.js';
 import 'lodash/isEqual';
 import '../actions/Action.js';
-import 'lodash/debounce';
+import debounce from 'lodash/debounce';
 import '../utils/resize-sensor.js';
 import 'react-overlays/useRootClose';
 import '../utils/SimpleMap.js';
@@ -47,24 +47,65 @@ import '../utils/validations.js';
 import '../utils/resolveCondition.js';
 import 'mobx';
 import '../utils/Animation.js';
+import { createGlobalVarState, buildGlobalVariable } from '../globalVar.js';
 
 var RootStore = ServiceStore.named('RootStore')
     .props({
     runtimeError: types.frozen(),
     runtimeErrorStack: types.frozen(),
     query: types.frozen(),
-    ready: false
+    ready: false,
+    globalVarStates: types.optional(types.map(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 = 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, __assign(__assign({}, self.query), { __query: self.query }));
@@ -74,32 +115,459 @@ var RootStore = ServiceStore.named('RootStore')
     }
 }); })
     .actions(function (self) {
+    function updateState(key, state) {
+        return self.updateGlobalVarState(key, state);
+    }
     var init = flow(function init(fn) {
-        var ret;
+        var ret, e_1;
         return __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 = __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 = __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 __awaiter(this, void 0, void 0, function () {
+            var value, state;
+            return __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 __awaiter(this, void 0, void 0, function () {
+            var value;
+            return __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 __awaiter(this, void 0, void 0, function () {
+            var data, _loop_2, key;
+            return __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, __assign(__assign({}, context), { variables: variables }))];
+                    case 1:
+                        data = _a.sent();
+                        if (!isPlainObject(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 __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 __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        variables = newVars.concat(updateVars);
+                        context = __assign(__assign({}, self.context), { variables: variables });
+                        globalVars = variables.map(function (item) {
+                            return 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 = __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 = flow(function setGlobalVars(vars) {
+        var _a, newVars, updateVars, removeVars, _b;
+        return __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 __awaiter(this, void 0, void 0, function () {
+            return __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 __awaiter(this, void 0, void 0, function () {
+            return __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, __assign(__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 __awaiter(this, void 0, void 0, function () {
+            var context, setters, bulkSetters, values, _loop_4, _a, _b, varItem;
+            var e_4, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        context = __assign(__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 = __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(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 = __assign(__assign({}, (origin || 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;
@@ -110,7 +578,10 @@ var RootStore = ServiceStore.named('RootStore')
                 self.query = query;
             }
         },
-        init: init
+        init: init,
+        afterDestroy: function () {
+            lazySaveGlobalVarValues.flush();
+        }
     };
 });
 

package/esm/store/service.js

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

package/esm/store/status.js

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

package/esm/store/table.d.ts

@@ -225,6 +225,8 @@ export declare const TableStore: import("mobx-state-tree").IModelType<{
         resetDefered(): void;
         updateData({ children, ...rest }: any): void;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+    fullItems: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IType<any, any, any>>, [undefined]>;
+    fullSelectedItems: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IType<any, any, any>>, [undefined]>;
     selectedRows: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IModelType<{
         storeType: import("mobx-state-tree").IType<string | undefined, string, string>;
         id: import("mobx-state-tree").ISimpleType<string>;
@@ -295,6 +297,7 @@ export declare const TableStore: import("mobx-state-tree").IModelType<{
     draggable: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
     dragging: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
     selectable: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    showIndex: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
     multiple: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
     footable: import("mobx-state-tree").IType<any, any, any>;
     expandConfig: import("mobx-state-tree").IType<any, any, any>;
@@ -12811,7 +12814,7 @@ export declare const TableStore: import("mobx-state-tree").IModelType<{
     /** 已选择item是否达到数量上限 */
     readonly isSelectionThresholdReached: boolean;
     readonly firstToggledColumnIndex: number | null;
-    getData: (superData: any) => any;
+    getData(superData: any): any;
     readonly columnGroup: {
         rowSpan: number;
         label: any;
@@ -13234,6 +13237,17 @@ export declare const TableStore: import("mobx-state-tree").IModelType<{
         updateData({ children, ...rest }: any): void;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>)[];
     buildStyles(style: any): any;
+    /**
+     * 构建事件的上下文数据
+     * @param buildChain
+     * @returns
+     */
+    readonly eventContext: {
+        selectedItems: any[];
+        selectedIndexes: string[];
+        items: any[];
+        unSelectedItems: any[];
+    };
 } & {
     setTable: (ref: HTMLElement | null) => void;
     getTable: () => HTMLElement | null;
@@ -13243,7 +13257,7 @@ export declare const TableStore: import("mobx-state-tree").IModelType<{
     updateColumns: (columns: Array<SColumn>) => void;
     initTableWidth: () => void;
     syncTableWidth: () => void;
-    initRows: (rows: Array<any>, getEntryId?: ((entry: any, index: number) => string) | undefined, reUseRow?: boolean | 'match') => void;
+    initRows: (rows: Array<any>, getEntryId?: ((entry: any, index: number) => string) | undefined, reUseRow?: boolean | 'match', fullItems?: Array<any>, fullSelectedItems?: Array<any>) => void;
     updateSelected: (selected: Array<any>, valueField?: string) => void;
     toggleAll: () => void;
     getSelectedRows: () => ({