amis-core 1.0.0-beta.0

package/dist/store/iRenderer.js

@@ -0,0 +1,189 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var mobxStateTree = require('mobx-state-tree');
+require('../utils/helper.js');
+require('amis-formula');
+require('moment');
+var object = require('../utils/object.js');
+var getVariable = require('../utils/getVariable.js');
+var dataMapping = require('../utils/dataMapping.js');
+require('../utils/filter.js');
+var SimpleMap = require('../utils/SimpleMap.js');
+var node = require('./node.js');
+
+var iRendererStore = node.StoreNode.named('iRendererStore')
+    .props({
+    hasRemoteData: mobxStateTree.types.optional(mobxStateTree.types.boolean, false),
+    data: mobxStateTree.types.optional(mobxStateTree.types.frozen(), {}),
+    initedAt: 0,
+    updatedAt: 0,
+    pristine: mobxStateTree.types.optional(mobxStateTree.types.frozen(), {}),
+    action: mobxStateTree.types.optional(mobxStateTree.types.frozen(), undefined),
+    dialogOpen: false,
+    dialogData: mobxStateTree.types.optional(mobxStateTree.types.frozen(), undefined),
+    drawerOpen: false,
+    drawerData: mobxStateTree.types.optional(mobxStateTree.types.frozen(), undefined)
+})
+    .views(function (self) { return ({
+    getValueByName: function (name, canAccessSuper) {
+        if (canAccessSuper === void 0) { canAccessSuper = true; }
+        return getVariable.getVariable(self.data, name, canAccessSuper);
+    },
+    getPristineValueByName: function (name) {
+        return getVariable.getVariable(self.pristine, name, false);
+    }
+}); })
+    .actions(function (self) {
+    var dialogCallbacks = new SimpleMap.SimpleMap();
+    return {
+        initData: function (data, skipSetPristine) {
+            if (data === void 0) { data = {}; }
+            if (skipSetPristine === void 0) { skipSetPristine = false; }
+            self.initedAt = Date.now();
+            !skipSetPristine && (self.pristine = data);
+            self.data = data;
+        },
+        reset: function () {
+            self.data = self.pristine;
+        },
+        updateData: function (data, tag, replace) {
+            if (data === void 0) { data = {}; }
+            var prev = self.data;
+            var newData;
+            if (tag) {
+                var proto = object.createObject(self.data.__super || null, tag);
+                newData = object.createObject(proto, tslib.__assign(tslib.__assign({}, (replace ? {} : self.data)), data));
+            }
+            else {
+                newData = object.extendObject(self.data, data, !replace);
+            }
+            Object.defineProperty(newData, '__prev', {
+                value: tslib.__assign({}, prev),
+                enumerable: false,
+                configurable: false,
+                writable: false
+            });
+            self.data = newData;
+        },
+        changeValue: function (name, value, changePristine, force, otherModifier) {
+            if (!name) {
+                return;
+            }
+            var origin = getVariable.getVariable(self.data, name, false);
+            if (value === origin && !force) {
+                return;
+            }
+            var prev = self.data;
+            var data = object.cloneObject(self.data);
+            if (prev.__prev) {
+                // 基于之前的 __prev 改
+                var prevData = object.cloneObject(prev.__prev);
+                object.setVariable(prevData, name, origin);
+                Object.defineProperty(data, '__prev', {
+                    value: prevData,
+                    enumerable: false,
+                    configurable: false,
+                    writable: false
+                });
+            }
+            else {
+                Object.defineProperty(data, '__prev', {
+                    value: tslib.__assign({}, prev),
+                    enumerable: false,
+                    configurable: false,
+                    writable: false
+                });
+            }
+            if (value === undefined) {
+                object.deleteVariable(data, name);
+            }
+            else {
+                object.setVariable(data, name, value);
+            }
+            otherModifier === null || otherModifier === void 0 ? void 0 : otherModifier(data);
+            if (changePristine) {
+                var pristine = object.cloneObject(self.pristine);
+                object.setVariable(pristine, name, value);
+                otherModifier === null || otherModifier === void 0 ? void 0 : otherModifier(pristine);
+                self.pristine = pristine;
+            }
+            if (!data.__pristine) {
+                Object.defineProperty(data, '__pristine', {
+                    value: self.pristine,
+                    enumerable: false,
+                    configurable: false,
+                    writable: false
+                });
+            }
+            self.data = data;
+        },
+        setCurrentAction: function (action) {
+            self.action = action;
+        },
+        openDialog: function (ctx, additonal, callback) {
+            var proto = ctx.__super ? ctx.__super : self.data;
+            if (additonal) {
+                proto = object.createObject(proto, additonal);
+            }
+            var data = object.createObject(proto, tslib.__assign({}, ctx));
+            if (self.action.dialog && self.action.dialog.data) {
+                self.dialogData = dataMapping.dataMapping(self.action.dialog.data, data);
+                var clonedAction = tslib.__assign(tslib.__assign({}, self.action), { dialog: tslib.__assign({}, self.action.dialog) });
+                delete clonedAction.dialog.data;
+                self.action = clonedAction;
+            }
+            else {
+                self.dialogData = data;
+            }
+            self.dialogOpen = true;
+            callback && dialogCallbacks.set(self.dialogData, callback);
+        },
+        closeDialog: function (result) {
+            var callback = dialogCallbacks.get(self.dialogData);
+            self.dialogOpen = false;
+            if (callback) {
+                dialogCallbacks.delete(self.dialogData);
+                setTimeout(function () { return callback(result); }, 200);
+            }
+        },
+        openDrawer: function (ctx, additonal, callback) {
+            var proto = ctx.__super ? ctx.__super : self.data;
+            if (additonal) {
+                proto = object.createObject(proto, additonal);
+            }
+            var data = object.createObject(proto, tslib.__assign({}, ctx));
+            if (self.action.drawer.data) {
+                self.drawerData = dataMapping.dataMapping(self.action.drawer.data, data);
+                var clonedAction = tslib.__assign(tslib.__assign({}, self.action), { dialog: tslib.__assign({}, self.action.dialog) });
+                delete clonedAction.dialog.data;
+                self.action = clonedAction;
+            }
+            else {
+                self.drawerData = data;
+            }
+            self.drawerOpen = true;
+            if (callback) {
+                dialogCallbacks.set(self.drawerData, callback);
+            }
+        },
+        closeDrawer: function (result) {
+            var callback = dialogCallbacks.get(self.drawerData);
+            self.drawerOpen = false;
+            if (callback) {
+                dialogCallbacks.delete(self.drawerData);
+                setTimeout(function () { return callback(result); }, 200);
+            }
+        }
+    };
+});
+// export type SIRendererStore = typeof iRendererStore.SnapshotType;
+
+exports.iRendererStore = iRendererStore;

package/dist/store/index.js

@@ -0,0 +1,103 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var mobxStateTree = require('mobx-state-tree');
+var iRenderer = require('./iRenderer.js');
+var service = require('./service.js');
+var combo = require('./combo.js');
+var form = require('./form.js');
+var crud = require('./crud.js');
+var table = require('./table.js');
+var tableV2 = require('./table-v2.js');
+var list = require('./list.js');
+var modal = require('./modal.js');
+var find = require('lodash/find');
+var formItem = require('./formItem.js');
+var manager = require('./manager.js');
+var pagination = require('./pagination.js');
+var app = require('./app.js');
+var root = require('./root.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var find__default = /*#__PURE__*/_interopDefaultLegacy(find);
+
+mobxStateTree.setLivelynessChecking(process.env.NODE_ENV === 'production' ? 'ignore' : 'error');
+var allowedStoreList = [
+    service.ServiceStore,
+    form.FormStore,
+    combo.ComboStore,
+    crud.CRUDStore,
+    table.TableStore,
+    tableV2.TableStoreV2,
+    list.ListStore,
+    modal.ModalStore,
+    formItem.FormItemStore,
+    pagination.PaginationStore,
+    app.AppStore
+];
+var RendererStore = mobxStateTree.types
+    .model('RendererStore', {
+    storeType: 'RendererStore'
+})
+    .props({
+    visibleState: mobxStateTree.types.optional(mobxStateTree.types.frozen(), {}),
+    disableState: mobxStateTree.types.optional(mobxStateTree.types.frozen(), {})
+})
+    .views(function (self) { return ({
+    get fetcher() {
+        return mobxStateTree.getEnv(self).fetcher;
+    },
+    get notify() {
+        return mobxStateTree.getEnv(self).notify;
+    },
+    get isCancel() {
+        return mobxStateTree.getEnv(self).isCancel;
+    },
+    get __() {
+        return mobxStateTree.getEnv(self).translate;
+    },
+    getStoreById: function (id) {
+        return manager.getStoreById(id);
+    },
+    get stores() {
+        return manager.getStores();
+    }
+}); })
+    .actions(function (self) { return ({
+    addStore: function (store) {
+        if (store.storeType === root.RootStore.name) {
+            return manager.addStore(root.RootStore.create(store, mobxStateTree.getEnv(self)));
+        }
+        var factory = find__default["default"](allowedStoreList, function (item) { return item.name === store.storeType; });
+        return manager.addStore(factory.create(store, mobxStateTree.getEnv(self)));
+    },
+    removeStore: function (store) {
+        // store.dispose();
+        manager.removeStore(store);
+    },
+    setVisible: function (id, value) {
+        var _a;
+        var state = tslib.__assign(tslib.__assign({}, self.visibleState), (_a = {}, _a[id] = value, _a));
+        self.visibleState = state;
+    },
+    setDisable: function (id, value) {
+        var _a;
+        var state = tslib.__assign(tslib.__assign({}, self.disableState), (_a = {}, _a[id] = value, _a));
+        self.disableState = state;
+    }
+}); });
+var RegisterStore = function (store) {
+    allowedStoreList.push(store);
+};
+
+exports.iRendererStore = iRenderer.iRendererStore;
+exports.RegisterStore = RegisterStore;
+exports.RendererStore = RendererStore;

package/dist/store/list.js

@@ -0,0 +1,248 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var mobxStateTree = require('mobx-state-tree');
+var iRenderer = require('./iRenderer.js');
+var isEqual = require('lodash/isEqual');
+var find = require('lodash/find');
+var helper = require('../utils/helper.js');
+var tpl = require('../utils/tpl.js');
+var object = require('../utils/object.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
+var find__default = /*#__PURE__*/_interopDefaultLegacy(find);
+
+var Item = mobxStateTree.types
+    .model('Item', {
+    id: mobxStateTree.types.identifier,
+    pristine: mobxStateTree.types.frozen(),
+    data: mobxStateTree.types.frozen(),
+    index: mobxStateTree.types.number,
+    newIndex: mobxStateTree.types.number
+})
+    .views(function (self) { return ({
+    get checked() {
+        return mobxStateTree.getParent(self, 2).isSelected(self);
+    },
+    get modified() {
+        if (!self.data) {
+            return false;
+        }
+        return Object.keys(self.data).some(function (key) { return !isEqual__default["default"](self.data[key], self.pristine[key]); });
+    },
+    get moved() {
+        return self.index !== self.newIndex;
+    },
+    get locals() {
+        return object.createObject(object.extendObject(mobxStateTree.getParent(self, 2).data, {
+            index: self.index
+        }), self.data);
+    },
+    get checkable() {
+        var table = mobxStateTree.getParent(self, 2);
+        return table && table.itemCheckableOn
+            ? tpl.evalExpression(table.itemCheckableOn, self.locals)
+            : true;
+    },
+    get draggable() {
+        var table = mobxStateTree.getParent(self, 2);
+        return table && table.itemDraggableOn
+            ? tpl.evalExpression(table.itemDraggableOn, self.locals)
+            : true;
+    }
+}); })
+    .actions(function (self) { return ({
+    toggle: function () {
+        mobxStateTree.getParent(self, 2).toggle(self);
+    },
+    change: function (values, savePristine) {
+        self.data = helper.immutableExtends(self.data, values);
+        savePristine && (self.pristine = self.data);
+    },
+    reset: function () {
+        self.newIndex = self.index;
+        self.data = self.pristine;
+    }
+}); });
+var ListStore = iRenderer.iRendererStore
+    .named('ListStore')
+    .props({
+    items: mobxStateTree.types.array(Item),
+    selectedItems: mobxStateTree.types.array(mobxStateTree.types.reference(Item)),
+    primaryField: 'id',
+    orderBy: '',
+    orderDir: mobxStateTree.types.optional(mobxStateTree.types.union(mobxStateTree.types.literal('asc'), mobxStateTree.types.literal('desc')), 'asc'),
+    draggable: false,
+    dragging: false,
+    multiple: true,
+    selectable: false,
+    itemCheckableOn: '',
+    itemDraggableOn: '',
+    hideCheckToggler: false
+})
+    .views(function (self) {
+    function isSelected(item) {
+        return !!~self.selectedItems.indexOf(item);
+    }
+    function getModifiedItems() {
+        return self.items.filter(function (item) { return item.modified; });
+    }
+    function getModified() {
+        return getModifiedItems().length;
+    }
+    function getMovedItems() {
+        return self.items.filter(function (item) { return item.moved; });
+    }
+    function getMovied() {
+        return getMovedItems().length;
+    }
+    return {
+        get allChecked() {
+            return !!(self.selectedItems.length ===
+                self.checkableItems.length &&
+                self.checkableItems.length);
+        },
+        get checkableItems() {
+            return self.items.filter(function (item) { return item.checkable; });
+        },
+        get unSelectedItems() {
+            return self.items.filter(function (item) { return !item.checked; });
+        },
+        isSelected: isSelected,
+        get modified() {
+            return getModified();
+        },
+        get modifiedItems() {
+            return getModifiedItems();
+        },
+        get moved() {
+            return getMovied();
+        },
+        get movedItems() {
+            return getMovedItems();
+        }
+    };
+})
+    .actions(function (self) {
+    function update(config) {
+        config.selectable === void 0 || (self.selectable = config.selectable);
+        config.draggable === void 0 || (self.draggable = config.draggable);
+        config.multiple === void 0 || (self.multiple = config.multiple);
+        config.hideCheckToggler === void 0 ||
+            (self.hideCheckToggler = config.hideCheckToggler);
+        if (typeof config.orderBy !== 'undefined') {
+            setOrderByInfo(config.orderBy, config.orderDir === 'desc' ? 'desc' : 'asc');
+        }
+        config.itemCheckableOn === void 0 ||
+            (self.itemCheckableOn = config.itemCheckableOn);
+        config.itemDraggableOn === void 0 ||
+            (self.itemDraggableOn = config.itemDraggableOn);
+    }
+    function initItems(items) {
+        var arr = items.map(function (item, key) {
+            item = object.isObject(item)
+                ? item
+                : {
+                    item: item
+                };
+            return {
+                // id: String((item as any)[self.primaryField] || key),
+                id: helper.guid(),
+                index: key,
+                newIndex: key,
+                pristine: item,
+                data: item,
+                modified: false
+            };
+        });
+        self.selectedItems.clear();
+        self.items.replace(arr);
+        self.dragging = false;
+    }
+    function updateSelected(selected, valueField) {
+        self.selectedItems.clear();
+        self.items.forEach(function (item) {
+            if (~selected.indexOf(item.pristine)) {
+                self.selectedItems.push(item);
+            }
+            else if (find__default["default"](selected, function (a) {
+                return a[valueField || 'value'] == item.pristine[valueField || 'value'];
+            })) {
+                self.selectedItems.push(item);
+            }
+        });
+    }
+    function toggleAll() {
+        if (self.allChecked) {
+            self.selectedItems.clear();
+        }
+        else {
+            self.selectedItems.replace(self.checkableItems);
+        }
+    }
+    function toggle(item) {
+        if (!item.checkable) {
+            return;
+        }
+        var idx = self.selectedItems.indexOf(item);
+        if (self.multiple) {
+            ~idx
+                ? self.selectedItems.splice(idx, 1)
+                : self.selectedItems.push(item);
+        }
+        else {
+            ~idx
+                ? self.selectedItems.splice(idx, 1)
+                : self.selectedItems.replace([item]);
+        }
+    }
+    function clear() {
+        self.selectedItems.clear();
+    }
+    function setOrderByInfo(key, direction) {
+        self.orderBy = key;
+        self.orderDir = direction;
+    }
+    function reset() {
+        self.items.forEach(function (item) { return item.reset(); });
+        self.dragging = false;
+    }
+    function toggleDragging() {
+        self.dragging = !self.dragging;
+    }
+    function stopDragging() {
+        self.dragging = false;
+    }
+    function exchange(fromIndex, toIndex) {
+        var item = self.items[fromIndex];
+        item.newIndex = toIndex;
+        var newItems = self.items.slice();
+        newItems.splice(fromIndex, 1);
+        newItems.splice(toIndex, 0, item);
+        self.items.replace(newItems);
+    }
+    return {
+        update: update,
+        initItems: initItems,
+        updateSelected: updateSelected,
+        toggleAll: toggleAll,
+        toggle: toggle,
+        clear: clear,
+        setOrderByInfo: setOrderByInfo,
+        reset: reset,
+        toggleDragging: toggleDragging,
+        stopDragging: stopDragging,
+        exchange: exchange
+    };
+});
+
+exports.Item = Item;
+exports.ListStore = ListStore;

package/dist/store/manager.js

@@ -0,0 +1,56 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var mobxStateTree = require('mobx-state-tree');
+
+var stores = {};
+function addStore(store) {
+    if (stores[store.id]) {
+        return stores[store.id];
+    }
+    stores[store.id] = store;
+    // drawer dialog 不加进去，否则有些容器就不会自我销毁 store 了。
+    if (store.parentId && !/(?:dialog|drawer)$/.test(store.path)) {
+        var parent_1 = stores[store.parentId];
+        parent_1.addChildId(store.id);
+    }
+    cleanUp();
+    return store;
+}
+var toDelete = [];
+function removeStore(store) {
+    var id = store.id;
+    toDelete.push(id);
+    store.dispose(cleanUp);
+}
+function cleanUp() {
+    var index = toDelete.length - 1;
+    while (index >= 0) {
+        var id = toDelete[index];
+        var store = stores[id];
+        if (store && !mobxStateTree.isAlive(store)) {
+            delete stores[id];
+            toDelete.splice(index, 1);
+        }
+        else {
+            index--;
+        }
+    }
+}
+function getStoreById(id) {
+    return stores[id];
+}
+function getStores() {
+    return stores;
+}
+
+exports.addStore = addStore;
+exports.getStoreById = getStoreById;
+exports.getStores = getStores;
+exports.removeStore = removeStore;

package/dist/store/modal.js

@@ -0,0 +1,54 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var service = require('./service.js');
+var mobxStateTree = require('mobx-state-tree');
+require('../utils/helper.js');
+var object = require('../utils/object.js');
+
+var ModalStore = service.ServiceStore.named('ModalStore')
+    .props({
+    form: mobxStateTree.types.frozen(),
+    entered: false,
+    resizeCoord: 0,
+    schema: mobxStateTree.types.frozen()
+})
+    .views(function (self) {
+    return {
+        get formData() {
+            return object.createObject(self.data, self.form);
+        }
+    };
+})
+    .actions(function (self) {
+    return {
+        setEntered: function (value) {
+            self.entered = value;
+        },
+        setFormData: function (obj) {
+            self.form = obj;
+        },
+        reset: function () {
+            self.form = {};
+            self.reInitData({}, true);
+        },
+        setResizeCoord: function (value) {
+            self.resizeCoord = value;
+        },
+        setSchema: function (schema) {
+            if (schema && schema.then) {
+                schema.then(function (value) { return mobxStateTree.isAlive(self) && self.setSchema(value); });
+                return;
+            }
+            self.schema = schema;
+        }
+    };
+});
+
+exports.ModalStore = ModalStore;