amis-core 1.0.0-beta.0

package/dist/store/app.js

@@ -0,0 +1,190 @@
+/**
+ * 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 helper = require('../utils/helper.js');
+var service = require('./service.js');
+var object = require('../utils/object.js');
+
+var AppStore = service.ServiceStore.named('AppStore')
+    .props({
+    pages: mobxStateTree.types.frozen(),
+    activePage: mobxStateTree.types.frozen(),
+    folded: false,
+    offScreen: false
+})
+    .views(function (self) { return ({
+    get navigations() {
+        if (Array.isArray(self.pages)) {
+            return helper.mapTree(self.pages, function (item) {
+                var visible = item.visible;
+                if (visible !== false &&
+                    item.path &&
+                    !~item.path.indexOf('http') &&
+                    ~item.path.indexOf(':')) {
+                    visible = false;
+                }
+                return {
+                    label: item.label,
+                    icon: item.icon,
+                    path: item.path,
+                    children: item.children,
+                    className: item.className,
+                    visible: visible
+                };
+            });
+        }
+        return [
+            {
+                label: self.__('App.navigation'),
+                children: []
+            }
+        ];
+    },
+    get bcn() {
+        var _a;
+        return ((_a = self.activePage) === null || _a === void 0 ? void 0 : _a.bcn) || [];
+    },
+    get pageData() {
+        var _a;
+        return object.createObject(self.data, {
+            params: ((_a = self.activePage) === null || _a === void 0 ? void 0 : _a.params) || {}
+        });
+    }
+}); })
+    .actions(function (self) { return ({
+    toggleFolded: function () {
+        self.folded = !self.folded;
+    },
+    toggleOffScreen: function () {
+        self.offScreen = !self.offScreen;
+    },
+    setPages: function (pages) {
+        if (pages && !Array.isArray(pages)) {
+            pages = [pages];
+        }
+        else if (!Array.isArray(pages)) {
+            return;
+        }
+        pages = helper.mapTree(pages, function (item, index, level, paths) {
+            var path = item.link || item.url;
+            if (item.schema || item.schemaApi) {
+                path =
+                    item.url ||
+                        "/".concat(paths
+                            .map(function (item) { return item.index; })
+                            .concat(index)
+                            .map(function (index) { return "page-".concat(index + 1); })
+                            .join('/'));
+                if (path && path[0] !== '/') {
+                    var parentPath = '/';
+                    var index_1 = paths.length;
+                    while (index_1 > 0) {
+                        var item_1 = paths[index_1 - 1];
+                        if (item_1 === null || item_1 === void 0 ? void 0 : item_1.path) {
+                            parentPath = item_1.path + '/';
+                            break;
+                        }
+                        index_1--;
+                    }
+                    path = parentPath + path;
+                }
+            }
+            return tslib.__assign(tslib.__assign({}, item), { index: index, id: item.id || helper.guid(), label: item.label, icon: item.icon, path: path });
+        });
+        self.pages = pages;
+    },
+    rewrite: function (to, env) {
+        var page = helper.findTree(self.pages, function (item) {
+            if (item.path === to) {
+                return true;
+            }
+            return false;
+        });
+        if (page) {
+            this.setActivePage(page, env);
+        }
+    },
+    setActivePage: function (page, env, params) {
+        var _a;
+        // 同一个页面直接返回。
+        if (((_a = self.activePage) === null || _a === void 0 ? void 0 : _a.id) === page.id) {
+            return;
+        }
+        var bcn = [];
+        helper.findTree(self.pages, function (item, index, level, paths) {
+            if (item.id === page.id) {
+                bcn = paths.filter(function (item) { return item.path && item.label; });
+                bcn.push(tslib.__assign(tslib.__assign({}, item), { path: '' }));
+                self.__;
+                if (bcn[0].path !== '/') {
+                    bcn.unshift({
+                        label: self.__('App.home'),
+                        path: '/'
+                    });
+                }
+                return true;
+            }
+            return false;
+        });
+        self.activePage = tslib.__assign(tslib.__assign({}, page), { params: params || {}, bcn: bcn });
+        if (page.label) {
+            document.title = page.label;
+        }
+        if (page.schema) {
+            self.schema = page.schema;
+            self.schemaKey = '' + Date.now();
+        }
+        else if (page.schemaApi) {
+            self.schema = null;
+            self.fetchSchema(page.schemaApi, self.activePage, { method: 'get' });
+        }
+        else if (page.redirect) {
+            env.jumpTo(page.redirect);
+            return;
+        }
+        else if (page.rewrite) {
+            this.rewrite(page.rewrite, env);
+        }
+        else {
+            self.schema = null;
+            self.schemaKey = '';
+        }
+    },
+    updateActivePage: function (env) {
+        if (!Array.isArray(self.pages)) {
+            return;
+        }
+        var matched;
+        var page = helper.findTree(self.pages, function (item) {
+            if (item.path) {
+                matched = env.isCurrentUrl(item.path, item);
+                if (matched) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        if (page) {
+            this.setActivePage(page, env, typeof matched === 'object' ? matched.params : undefined);
+        }
+        else {
+            var page_1 = helper.findTree(self.pages, function (item) { return item.isDefaultPage; });
+            if (page_1) {
+                this.setActivePage(page_1, env);
+            }
+            else {
+                self.activePage = null;
+            }
+        }
+    }
+}); });
+
+exports.AppStore = AppStore;

package/dist/store/combo.js

@@ -0,0 +1,154 @@
+/**
+ * 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 manager = require('./manager.js');
+
+var UniqueGroup = mobxStateTree.types
+    .model('UniqueGroup', {
+    name: mobxStateTree.types.identifier,
+    itemsRef: mobxStateTree.types.array(mobxStateTree.types.string)
+})
+    .views(function (self) { return ({
+    get items() {
+        return self.itemsRef.map(function (id) { return manager.getStoreById(id); });
+    }
+}); })
+    .actions(function (self) { return ({
+    removeItem: function (item) {
+        self.itemsRef.replace(self.itemsRef.filter(function (id) { return id !== item.id; }));
+    },
+    addItem: function (item) {
+        self.itemsRef.push(item.id);
+    }
+}); });
+var ComboStore = iRenderer.iRendererStore
+    .named('ComboStore')
+    .props({
+    uniques: mobxStateTree.types.map(UniqueGroup),
+    multiple: false,
+    formsRef: mobxStateTree.types.optional(mobxStateTree.types.array(mobxStateTree.types.string), []),
+    minLength: 0,
+    maxLength: 0,
+    length: 0,
+    activeKey: 0
+})
+    .views(function (self) {
+    function getForms() {
+        return self.formsRef.map(function (item) { return manager.getStoreById(item); });
+    }
+    return {
+        get forms() {
+            return getForms();
+        },
+        get addable() {
+            if (self.maxLength && self.length >= self.maxLength) {
+                return false;
+            }
+            if (self.uniques.size) {
+                var isFull_1 = false;
+                self.uniques.forEach(function (item) {
+                    if (isFull_1 || !item.items.length) {
+                        return;
+                    }
+                    var total = item.items[0].options.length;
+                    var current = item.items.reduce(function (total, item) {
+                        return total + item.selectedOptions.length;
+                    }, 0);
+                    isFull_1 = total && current >= total ? true : false;
+                });
+                if (isFull_1) {
+                    return false;
+                }
+            }
+            return true;
+        },
+        get removable() {
+            if (self.minLength && self.minLength >= self.length) {
+                return false;
+            }
+            return true;
+        },
+        /**
+         * name 值有两种类型：
+         * 1. 数字索引，出现在多条模式下，这个时候，需要返回当前索引下的form，并且用于下一层的遍历搜索
+         * 2. 普通的表单项 name 值，出现在单条模式下，当前这层查找已经结束，所以要返回当前找到的items，而不能返回form
+         *
+         * @param name 查找的name
+         */
+        getItemsByName: function (name) {
+            var forms = getForms();
+            return self.multiple
+                ? [forms[parseInt(name, 10)]]
+                : forms[0].getItemsByName(name);
+        }
+    };
+})
+    .actions(function (self) {
+    function config(setting) {
+        typeof setting.multiple !== 'undefined' &&
+            (self.multiple = setting.multiple);
+        typeof setting.minLength !== 'undefined' &&
+            (self.minLength = parseInt(setting.minLength, 10));
+        typeof setting.maxLength !== 'undefined' &&
+            (self.maxLength = parseInt(setting.maxLength, 10));
+        typeof setting.length !== 'undefined' && (self.length = setting.length);
+    }
+    function bindUniuqueItem(item) {
+        if (!self.uniques.has(item.name)) {
+            self.uniques.put({
+                name: item.name
+            });
+        }
+        var group = self.uniques.get(item.name);
+        group.addItem(item);
+    }
+    function unBindUniuqueItem(item) {
+        var group = self.uniques.get(item.name);
+        group.removeItem(item);
+        if (!group.items.length) {
+            self.uniques.delete(item.name);
+        }
+    }
+    function addForm(form) {
+        self.formsRef.push(form.id);
+    }
+    function onChildStoreDispose(child) {
+        if (child.storeType === 'FormStore') {
+            var idx = self.formsRef.indexOf(child.id);
+            if (~idx) {
+                self.formsRef.splice(idx, 1);
+                child.items.forEach(function (item) {
+                    if (item.unique) {
+                        unBindUniuqueItem(item);
+                    }
+                });
+                self.forms.forEach(function (form) {
+                    return form.items.forEach(function (item) { return item.unique && item.syncOptions(undefined, form.data); });
+                });
+            }
+        }
+        self.removeChildId(child.id);
+    }
+    function setActiveKey(key) {
+        self.activeKey = key;
+    }
+    return {
+        config: config,
+        setActiveKey: setActiveKey,
+        bindUniuqueItem: bindUniuqueItem,
+        unBindUniuqueItem: unBindUniuqueItem,
+        addForm: addForm,
+        onChildStoreDispose: onChildStoreDispose
+    };
+});
+
+exports.ComboStore = ComboStore;
+exports.UniqueGroup = UniqueGroup;