vap1 0.2.2 → 0.2.4

package/components/Trees/ActionTree.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -31,23 +42,75 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getResponseList = exports.renderRoot = exports.ActionTree = exports.useActionTree = void 0;
-const react_1 = __importStar(require("react"));
-const lodash_1 = __importDefault(require("lodash"));
-const antd_1 = require("antd");
-const Popconfirm_1 = require("../_adapt/Popconfirm");
-const Dropdown_1 = require("../_adapt/Dropdown");
-const BaseTree_1 = require("./BaseTree");
-const Icon_1 = require("../_adapt/Icon");
-const UFormModal_1 = require("../UForm/UFormModal");
-const utils_1 = require("../../utils");
-const Const_1 = require("../_setup/Const");
-const useModals_1 = require("../../hooks/useModals");
-const STEP = 16;
+var react_1 = __importStar(require("react"));
+var lodash_1 = __importDefault(require("lodash"));
+var antd_1 = require("antd");
+var Popconfirm_1 = require("../_adapt/Popconfirm");
+var Dropdown_1 = require("../_adapt/Dropdown");
+var BaseTree_1 = require("./BaseTree");
+var Icon_1 = require("../_adapt/Icon");
+var UFormModal_1 = require("../UForm/UFormModal");
+var utils_1 = require("../../utils");
+var Const_1 = require("../_setup/Const");
+var useModals_1 = require("../../hooks/useModals");
+var STEP = 16;
 var INSER_POS;
 (function (INSER_POS) {
     INSER_POS[INSER_POS["BEFORE"] = 0] = "BEFORE";
@@ -57,15 +120,15 @@ var INSER_POS;
     INSER_POS[INSER_POS["BOTTOM"] = 4] = "BOTTOM";
 })(INSER_POS || (INSER_POS = {}));
 ;
-const { txt } = utils_1.i18n;
-const ActionTreeContext = (0, react_1.createContext)(null);
-const useActionTree = () => (0, react_1.useContext)(ActionTreeContext);
+var txt = utils_1.i18n.txt;
+var ActionTreeContext = (0, react_1.createContext)(null);
+var useActionTree = function () { return (0, react_1.useContext)(ActionTreeContext); };
 exports.useActionTree = useActionTree;
-const _Actiontree = (0, react_1.forwardRef)((props, ref) => {
-    const { treeState, setTreeData } = (0, BaseTree_1.useBaseTree)();
-    const modals = (0, useModals_1.useModals)();
-    const FIELDS = (0, react_1.useRef)([]);
-    const getDefault = (0, react_1.useCallback)(() => {
+var _Actiontree = (0, react_1.forwardRef)(function (props, ref) {
+    var _a = (0, BaseTree_1.useBaseTree)(), treeState = _a.treeState, setTreeData = _a.setTreeData;
+    var modals = (0, useModals_1.useModals)();
+    var FIELDS = (0, react_1.useRef)([]);
+    var getDefault = (0, react_1.useCallback)(function () {
         if (props.formDefault == null)
             return {};
         if (lodash_1.default.isPlainObject(props.formDefault))
@@ -74,7 +137,7 @@ const _Actiontree = (0, react_1.forwardRef)((props, ref) => {
             return props.formDefault(treeState.selectedNode);
         return {};
     }, [treeState.selectedNode]);
-    const action = {
+    var action = {
         objectName: '',
         canAdd: false,
         canAddRoot: false,
@@ -108,26 +171,30 @@ const _Actiontree = (0, react_1.forwardRef)((props, ref) => {
         if (props.canSort && treeState.sortField)
             action.canSort = true;
     }
-    (0, react_1.useImperativeHandle)(ref, () => ({
-        updateData, update, del, add: (data, position) => {
-            let nodePath = position.map(i => `[${i}]`).join('.children');
-            const { treeData } = treeState;
-            let node = lodash_1.default.get(treeData, nodePath);
+    (0, react_1.useImperativeHandle)(ref, function () { return ({
+        updateData: updateData,
+        update: update,
+        del: del,
+        add: function (data, position) {
+            var nodePath = position.map(function (i) { return "[".concat(i, "]"); }).join('.children');
+            var treeData = treeState.treeData;
+            var node = lodash_1.default.get(treeData, nodePath);
             if (node == null) {
                 antd_1.message.error('No parent found');
             }
-            add(data, { pos: INSER_POS.INNER, node, position });
+            add(data, { pos: INSER_POS.INNER, node: node, position: position });
         }
-    }), [treeState.treeData]);
-    (0, react_1.useLayoutEffect)(() => {
+    }); }, [treeState.treeData]);
+    (0, react_1.useLayoutEffect)(function () {
         if (props.formFields) {
             FIELDS.current = props.formFields;
             return;
         }
-        let fields = [];
+        var fields = [];
         if (treeState.langs) {
-            treeState.langs.map(({ lang, field }) => {
-                fields.push({ title: `${action.objectName}(${lang})`, field: field });
+            treeState.langs.map(function (_a) {
+                var lang = _a.lang, field = _a.field;
+                fields.push({ title: "".concat(action.objectName, "(").concat(lang, ")"), field: field });
             });
         }
         else {
@@ -136,371 +203,435 @@ const _Actiontree = (0, react_1.forwardRef)((props, ref) => {
         FIELDS.current = fields;
         // ref.current
     }, []);
-    const showAdd = (pos, node, position) => modals.showAdd({ pos, node, position });
-    const showEdit = (node, position) => modals.showEdit(node, { position });
+    var showAdd = function (pos, node, position) { return modals.showAdd({ pos: pos, node: node, position: position }); };
+    var showEdit = function (node, position) { return modals.showEdit(node, { position: position }); };
     // ref.
-    const addRoot = (data, extra) => __awaiter(void 0, void 0, void 0, function* () {
-        const { pos, position } = extra;
-        const { parentField, titleField, sortField, rootCode, treeData } = treeState;
-        if (position.length > 2)
-            return;
-        if (position.length == 2) {
-            if (treeData.length != 1)
-                return;
-            let child = treeData[0].children || [];
-            if (child.length == 0) {
-                addInner(data, { pos: INSER_POS.INNER, node: treeData[0], position: [0] });
-                return;
-            }
-            if (pos == INSER_POS.TOP) {
-                add(data, { pos: INSER_POS.BEFORE, node: child[0], position: [0, 0] });
-            }
-            else {
-                add(data, { pos: INSER_POS.AFTER, node: child[child.length - 1], position: [0, child.length - 1] });
-            }
-            return;
-        }
-        const { api, objectName, } = action;
-        let sort = 0;
-        if (treeData.length) {
-            if (pos == INSER_POS.TOP) {
-                sort = treeData[0][sortField] - STEP;
-            }
-            else {
-                sort = treeData[treeData.length - 1][sortField] + STEP;
-            }
-        }
-        var param = Object.assign(Object.assign({}, data), { [parentField]: rootCode, sort });
-        const result = yield utils_1.Ajax.PUT(api, param);
-        if (result.code != '0') {
-            antd_1.message.error(txt(Const_1.V.ACT_ADD_FAIL_NAMED, `${objectName} : ${data[titleField]}`));
-            return;
-        }
-        antd_1.message.success(txt(Const_1.V.ACT_ADD_SUCCESS_NAMED, `${objectName} : ${data[titleField]}`));
-        props.clearCache(rootCode);
-        let tree = utils_1.ArrayUtil.add(treeData, result.data);
-        setTreeData(tree);
-    });
-    const addInner = (data, extra) => __awaiter(void 0, void 0, void 0, function* () {
-        const { node, position } = extra;
-        const { api, objectName, canSort, } = action;
-        const { parentField, titleField, sortField, keyField, treeData } = treeState;
-        const root = lodash_1.default.concat([], position);
-        let nodePath = root.map(i => `[${i}]`).join('.children');
-        // if(nodePath)
-        let rootPath = nodePath + '.children';
-        var tree = lodash_1.default.concat([], treeData);
-        let arr = lodash_1.default.get(tree, rootPath);
-        if (arr == null)
-            arr = [];
-        var param = Object.assign(Object.assign({}, data), { [parentField]: node[keyField] });
-        if (canSort) {
-            let sort = STEP;
-            if (arr == null) {
-                if (lodash_1.default.isFunction(props.getChildren)) {
-                    arr = yield props.getChildren(node[keyField]);
-                }
-            }
-            if (arr && arr.length) {
-                sort = arr[arr.length - 1][sortField] + STEP;
-            }
-            param[sortField] = sort;
-        }
-        const resp = yield utils_1.Ajax.PUT(api, param);
-        if (resp.code != '0') {
-            antd_1.message.error(txt(Const_1.V.ACT_ADD_FAIL_NAMED, `${objectName} : ${data[titleField]}`));
-            return;
-        }
-        antd_1.message.success(txt(Const_1.V.ACT_ADD_SUCCESS_NAMED, `${objectName} : ${data[titleField]}`));
-        arr.push(resp.data);
-        props.clearCache(node[keyField]);
-        lodash_1.default.set(tree, rootPath, arr);
-        setTreeData(tree);
-    });
-    const add = (data, extra) => __awaiter(void 0, void 0, void 0, function* () {
-        const { pos, position } = extra;
-        if (position.length <= 0)
-            return;
-        if (pos == INSER_POS.TOP || pos == INSER_POS.BOTTOM) {
-            addRoot(data, extra);
-            return;
-        }
-        let root = lodash_1.default.concat([], position);
-        if (pos == INSER_POS.INNER) {
-            addInner(data, extra);
-            return;
-        }
-        const { idForApiField } = props;
-        const { api, objectName, canSort } = action;
-        const { parentField, titleField, sortField, keyField, treeData } = treeState;
-        const idField = idForApiField || keyField;
-        var tree = lodash_1.default.concat([], treeData);
-        let idx = root.pop();
-        let nodePath;
-        let arr;
-        if (root.length == 0) {
-            arr = tree;
-        }
-        else {
-            nodePath = root.map(i => `[${i}].children`).join('');
-            arr = lodash_1.default.get(tree, nodePath);
-        }
-        const obj = arr[idx];
-        let promises = [];
-        let needLoop = false;
-        let lastSort = STEP;
-        let dataDefault = getDefault();
-        if (!canSort) {
-            promises.push(utils_1.Ajax.PUT(api, Object.assign(Object.assign(Object.assign({}, dataDefault), data), { [parentField]: obj[parentField] })));
-        }
-        else if (pos == INSER_POS.BEFORE) {
-            try {
-                lastSort = parseInt(obj[sortField]);
-            }
-            catch (_a) {
+    var addRoot = function (data, extra) { return __awaiter(void 0, void 0, void 0, function () {
+        var pos, position, parentField, titleField, sortField, rootCode, treeData, child, api, objectName, sort, param, result, tree;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    pos = extra.pos, position = extra.position;
+                    parentField = treeState.parentField, titleField = treeState.titleField, sortField = treeState.sortField, rootCode = treeState.rootCode, treeData = treeState.treeData;
+                    if (position.length > 2)
+                        return [2 /*return*/];
+                    if (position.length == 2) {
+                        if (treeData.length != 1)
+                            return [2 /*return*/];
+                        child = treeData[0].children || [];
+                        if (child.length == 0) {
+                            addInner(data, { pos: INSER_POS.INNER, node: treeData[0], position: [0] });
+                            return [2 /*return*/];
+                        }
+                        if (pos == INSER_POS.TOP) {
+                            add(data, { pos: INSER_POS.BEFORE, node: child[0], position: [0, 0] });
+                        }
+                        else {
+                            add(data, { pos: INSER_POS.AFTER, node: child[child.length - 1], position: [0, child.length - 1] });
+                        }
+                        return [2 /*return*/];
+                    }
+                    api = action.api, objectName = action.objectName;
+                    sort = 0;
+                    if (treeData.length) {
+                        if (pos == INSER_POS.TOP) {
+                            sort = treeData[0][sortField] - STEP;
+                        }
+                        else {
+                            sort = treeData[treeData.length - 1][sortField] + STEP;
+                        }
+                    }
+                    param = __assign(__assign({}, data), (_a = {}, _a[parentField] = rootCode, _a.sort = sort, _a));
+                    return [4 /*yield*/, utils_1.Ajax.PUT(api, param)];
+                case 1:
+                    result = _b.sent();
+                    if (result.code != '0') {
+                        antd_1.message.error(txt(Const_1.V.ACT_ADD_FAIL_NAMED, "".concat(objectName, " : ").concat(data[titleField])));
+                        return [2 /*return*/];
+                    }
+                    antd_1.message.success(txt(Const_1.V.ACT_ADD_SUCCESS_NAMED, "".concat(objectName, " : ").concat(data[titleField])));
+                    props.clearCache(rootCode);
+                    tree = utils_1.ArrayUtil.add(treeData, result.data);
+                    setTreeData(tree);
+                    return [2 /*return*/];
             }
-            if (idx == 0) {
-                promises.push(utils_1.Ajax.PUT(api, Object.assign(Object.assign(Object.assign({}, dataDefault), data), { [sortField]: lastSort - STEP, [parentField]: obj[parentField] })));
-            }
-            else {
-                let diff = Math.floor((lastSort - arr[idx - 1][sortField]) / 2);
-                if (diff > 0) {
-                    promises.push(utils_1.Ajax.PUT(api, Object.assign(Object.assign(Object.assign({}, dataDefault), data), { [sortField]: lastSort - diff, [parentField]: obj[parentField] })));
-                }
-                else {
-                    promises.push(utils_1.Ajax.PUT(api, Object.assign(Object.assign(Object.assign({}, dataDefault), data), { [sortField]: lastSort - STEP, [parentField]: obj[parentField] })));
-                    needLoop = true;
-                    lastSort = lastSort - STEP;
-                }
-            }
-            if (needLoop) {
-                for (let i = idx - 1; i >= 0; i--) {
-                    let item = arr[i];
-                    lastSort = lastSort - STEP;
-                    promises.push(utils_1.Ajax.PATCH(api, {
-                        [idField]: item[idField],
-                        [sortField]: lastSort,
-                    }));
-                    arr = utils_1.ArrayUtil.update(arr, Object.assign(Object.assign({}, item), { [sortField]: lastSort }), keyField);
-                }
-            }
-        }
-        else {
-            try {
-                lastSort = parseInt(obj[sortField]);
-            }
-            catch (_b) {
-            }
-            let len = arr.length;
-            if (idx == len - 1) {
-                promises.push(utils_1.Ajax.PUT(api, Object.assign(Object.assign(Object.assign({}, dataDefault), data), { [sortField]: lastSort + STEP, [parentField]: obj[parentField] })));
-            }
-            else {
-                let diff = Math.floor((arr[idx + 1][sortField] - lastSort) / 2);
-                if (diff > 0) {
-                    promises.push(utils_1.Ajax.PUT(api, Object.assign(Object.assign(Object.assign({}, dataDefault), data), { [sortField]: lastSort + diff, [parentField]: obj[parentField] })));
-                }
-                else {
-                    promises.push(utils_1.Ajax.PUT(api, Object.assign(Object.assign(Object.assign({}, dataDefault), data), { [sortField]: lastSort + STEP, [parentField]: obj[parentField] })));
-                    needLoop = true;
-                    lastSort = lastSort + STEP;
-                }
+        });
+    }); };
+    var addInner = function (data, extra) { return __awaiter(void 0, void 0, void 0, function () {
+        var node, position, api, objectName, canSort, parentField, titleField, sortField, keyField, treeData, root, nodePath, rootPath, tree, arr, param, sort, resp;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    node = extra.node, position = extra.position;
+                    api = action.api, objectName = action.objectName, canSort = action.canSort;
+                    parentField = treeState.parentField, titleField = treeState.titleField, sortField = treeState.sortField, keyField = treeState.keyField, treeData = treeState.treeData;
+                    root = lodash_1.default.concat([], position);
+                    nodePath = root.map(function (i) { return "[".concat(i, "]"); }).join('.children');
+                    rootPath = nodePath + '.children';
+                    tree = lodash_1.default.concat([], treeData);
+                    arr = lodash_1.default.get(tree, rootPath);
+                    if (arr == null)
+                        arr = [];
+                    param = __assign(__assign({}, data), (_a = {}, _a[parentField] = node[keyField], _a));
+                    if (!canSort) return [3 /*break*/, 3];
+                    sort = STEP;
+                    if (!(arr == null)) return [3 /*break*/, 2];
+                    if (!lodash_1.default.isFunction(props.getChildren)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, props.getChildren(node[keyField])];
+                case 1:
+                    arr = _b.sent();
+                    _b.label = 2;
+                case 2:
+                    if (arr && arr.length) {
+                        sort = arr[arr.length - 1][sortField] + STEP;
+                    }
+                    param[sortField] = sort;
+                    _b.label = 3;
+                case 3: return [4 /*yield*/, utils_1.Ajax.PUT(api, param)];
+                case 4:
+                    resp = _b.sent();
+                    if (resp.code != '0') {
+                        antd_1.message.error(txt(Const_1.V.ACT_ADD_FAIL_NAMED, "".concat(objectName, " : ").concat(data[titleField])));
+                        return [2 /*return*/];
+                    }
+                    antd_1.message.success(txt(Const_1.V.ACT_ADD_SUCCESS_NAMED, "".concat(objectName, " : ").concat(data[titleField])));
+                    arr.push(resp.data);
+                    props.clearCache(node[keyField]);
+                    lodash_1.default.set(tree, rootPath, arr);
+                    setTreeData(tree);
+                    return [2 /*return*/];
             }
-            if (needLoop) {
-                for (let i = idx + 1; i < len; i++) {
-                    let item = arr[i];
-                    lastSort = lastSort + STEP;
-                    promises.push(utils_1.Ajax.PATCH(api, {
-                        [keyField]: item[keyField],
-                        [sortField]: lastSort,
-                    }));
-                    arr = utils_1.ArrayUtil.update(arr, Object.assign(Object.assign({}, item), { [sortField]: lastSort }), keyField);
-                }
+        });
+    }); };
+    var add = function (data, extra) { return __awaiter(void 0, void 0, void 0, function () {
+        var pos, position, root, idForApiField, api, objectName, canSort, parentField, titleField, sortField, keyField, treeData, idField, tree, idx, nodePath, arr, obj, promises, needLoop, lastSort, dataDefault, diff, i, item, len, diff, i, item, resps, resp;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        return __generator(this, function (_m) {
+            switch (_m.label) {
+                case 0:
+                    pos = extra.pos, position = extra.position;
+                    if (position.length <= 0)
+                        return [2 /*return*/];
+                    if (pos == INSER_POS.TOP || pos == INSER_POS.BOTTOM) {
+                        addRoot(data, extra);
+                        return [2 /*return*/];
+                    }
+                    root = lodash_1.default.concat([], position);
+                    if (pos == INSER_POS.INNER) {
+                        addInner(data, extra);
+                        return [2 /*return*/];
+                    }
+                    idForApiField = props.idForApiField;
+                    api = action.api, objectName = action.objectName, canSort = action.canSort;
+                    parentField = treeState.parentField, titleField = treeState.titleField, sortField = treeState.sortField, keyField = treeState.keyField, treeData = treeState.treeData;
+                    idField = idForApiField || keyField;
+                    tree = lodash_1.default.concat([], treeData);
+                    idx = root.pop();
+                    if (root.length == 0) {
+                        arr = tree;
+                    }
+                    else {
+                        nodePath = root.map(function (i) { return "[".concat(i, "].children"); }).join('');
+                        arr = lodash_1.default.get(tree, nodePath);
+                    }
+                    obj = arr[idx];
+                    promises = [];
+                    needLoop = false;
+                    lastSort = STEP;
+                    dataDefault = getDefault();
+                    if (!canSort) {
+                        promises.push(utils_1.Ajax.PUT(api, __assign(__assign(__assign({}, dataDefault), data), (_a = {}, _a[parentField] = obj[parentField], _a))));
+                    }
+                    else if (pos == INSER_POS.BEFORE) {
+                        try {
+                            lastSort = parseInt(obj[sortField]);
+                        }
+                        catch (_o) {
+                        }
+                        if (idx == 0) {
+                            promises.push(utils_1.Ajax.PUT(api, __assign(__assign(__assign({}, dataDefault), data), (_b = {}, _b[sortField] = lastSort - STEP, _b[parentField] = obj[parentField], _b))));
+                        }
+                        else {
+                            diff = Math.floor((lastSort - arr[idx - 1][sortField]) / 2);
+                            if (diff > 0) {
+                                promises.push(utils_1.Ajax.PUT(api, __assign(__assign(__assign({}, dataDefault), data), (_c = {}, _c[sortField] = lastSort - diff, _c[parentField] = obj[parentField], _c))));
+                            }
+                            else {
+                                promises.push(utils_1.Ajax.PUT(api, __assign(__assign(__assign({}, dataDefault), data), (_d = {}, _d[sortField] = lastSort - STEP, _d[parentField] = obj[parentField], _d))));
+                                needLoop = true;
+                                lastSort = lastSort - STEP;
+                            }
+                        }
+                        if (needLoop) {
+                            for (i = idx - 1; i >= 0; i--) {
+                                item = arr[i];
+                                lastSort = lastSort - STEP;
+                                promises.push(utils_1.Ajax.PATCH(api, (_e = {},
+                                    _e[idField] = item[idField],
+                                    _e[sortField] = lastSort,
+                                    _e)));
+                                arr = utils_1.ArrayUtil.update(arr, __assign(__assign({}, item), (_f = {}, _f[sortField] = lastSort, _f)), keyField);
+                            }
+                        }
+                    }
+                    else {
+                        try {
+                            lastSort = parseInt(obj[sortField]);
+                        }
+                        catch (_p) {
+                        }
+                        len = arr.length;
+                        if (idx == len - 1) {
+                            promises.push(utils_1.Ajax.PUT(api, __assign(__assign(__assign({}, dataDefault), data), (_g = {}, _g[sortField] = lastSort + STEP, _g[parentField] = obj[parentField], _g))));
+                        }
+                        else {
+                            diff = Math.floor((arr[idx + 1][sortField] - lastSort) / 2);
+                            if (diff > 0) {
+                                promises.push(utils_1.Ajax.PUT(api, __assign(__assign(__assign({}, dataDefault), data), (_h = {}, _h[sortField] = lastSort + diff, _h[parentField] = obj[parentField], _h))));
+                            }
+                            else {
+                                promises.push(utils_1.Ajax.PUT(api, __assign(__assign(__assign({}, dataDefault), data), (_j = {}, _j[sortField] = lastSort + STEP, _j[parentField] = obj[parentField], _j))));
+                                needLoop = true;
+                                lastSort = lastSort + STEP;
+                            }
+                        }
+                        if (needLoop) {
+                            for (i = idx + 1; i < len; i++) {
+                                item = arr[i];
+                                lastSort = lastSort + STEP;
+                                promises.push(utils_1.Ajax.PATCH(api, (_k = {},
+                                    _k[keyField] = item[keyField],
+                                    _k[sortField] = lastSort,
+                                    _k)));
+                                arr = utils_1.ArrayUtil.update(arr, __assign(__assign({}, item), (_l = {}, _l[sortField] = lastSort, _l)), keyField);
+                            }
+                        }
+                    }
+                    return [4 /*yield*/, utils_1.Ajax.WHEN.apply(utils_1.Ajax, __spreadArray([], __read(promises), false))];
+                case 1:
+                    resps = _m.sent();
+                    resp = resps[0];
+                    if (resp.code != '0') {
+                        antd_1.message.error(txt(Const_1.V.ACT_ADD_FAIL_NAMED, "".concat(objectName, " : ").concat(data[titleField])));
+                        return [2 /*return*/];
+                    }
+                    antd_1.message.success(txt(Const_1.V.ACT_ADD_SUCCESS_NAMED, "".concat(objectName, " : ").concat(data[titleField])));
+                    arr = utils_1.ArrayUtil.add(arr, resp.data);
+                    if (canSort) {
+                        arr = lodash_1.default.orderBy(arr, sortField, 'asc');
+                    }
+                    if (nodePath) {
+                        lodash_1.default.set(tree, nodePath, arr);
+                    }
+                    else {
+                        tree = arr;
+                    }
+                    props.clearCache(obj[keyField]);
+                    setTreeData(tree);
+                    return [2 /*return*/];
             }
-        }
-        const resps = yield utils_1.Ajax.WHEN(...promises);
-        let resp = resps[0];
-        if (resp.code != '0') {
-            antd_1.message.error(txt(Const_1.V.ACT_ADD_FAIL_NAMED, `${objectName} : ${data[titleField]}`));
-            return;
-        }
-        antd_1.message.success(txt(Const_1.V.ACT_ADD_SUCCESS_NAMED, `${objectName} : ${data[titleField]}`));
-        arr = utils_1.ArrayUtil.add(arr, resp.data);
-        if (canSort) {
-            arr = lodash_1.default.orderBy(arr, sortField, 'asc');
-        }
-        if (nodePath) {
-            lodash_1.default.set(tree, nodePath, arr);
-        }
-        else {
-            tree = arr;
-        }
-        props.clearCache(obj[keyField]);
-        setTreeData(tree);
-    });
-    const updateData = (0, react_1.useCallback)((data, position) => {
+        });
+    }); };
+    var updateData = (0, react_1.useCallback)(function (data, position) {
         if (position.length == 0)
             return;
-        const { parentField, treeData } = treeState;
-        const root = lodash_1.default.concat([], position);
-        let tree = lodash_1.default.concat([], treeData);
-        let idx = root.pop();
-        let rootPath = '';
+        var parentField = treeState.parentField, treeData = treeState.treeData;
+        var root = lodash_1.default.concat([], position);
+        var tree = lodash_1.default.concat([], treeData);
+        var idx = root.pop();
+        var rootPath = '';
         if (root.length > 0) {
-            let nodePath = root.map(i => `[${i}]`).join('.children');
+            var nodePath = root.map(function (i) { return "[".concat(i, "]"); }).join('.children');
             rootPath = nodePath + '.children';
         }
-        let node = lodash_1.default.get(tree, `${rootPath}[${idx}]`);
+        var node = lodash_1.default.get(tree, "".concat(rootPath, "[").concat(idx, "]"));
         props.clearCache(lodash_1.default.get(node, parentField));
-        lodash_1.default.set(tree, rootPath + `[${idx}]`, data);
+        lodash_1.default.set(tree, rootPath + "[".concat(idx, "]"), data);
         setTreeData(tree);
     }, [treeState.treeData]);
-    const update = (0, react_1.useCallback)((data, position) => __awaiter(void 0, void 0, void 0, function* () {
-        if (position.length == 0)
-            return;
-        const { api, objectName } = action;
-        const { parentField, titleField, treeData } = treeState;
-        const resp = yield utils_1.Ajax.PATCH(api, data);
-        if (resp.code != '0') {
-            antd_1.message.error(txt(Const_1.V.ACT_UPDATE_FAIL_NAMED, `${objectName} : ${data[titleField]}`));
-            return;
-        }
-        const root = lodash_1.default.concat([], position);
-        let tree = lodash_1.default.concat([], treeData);
-        let idx = root.pop();
-        let rootPath = '';
-        if (root.length > 0) {
-            let nodePath = root.map(i => `[${i}]`).join('.children');
-            rootPath = nodePath + '.children';
-        }
-        antd_1.message.success(txt(Const_1.V.ACT_UPDATE_SUCCESS_NAMED, `${objectName} : ${data[titleField]}`));
-        let node = lodash_1.default.get(tree, `${rootPath}[${idx}]`);
-        if (node) {
-            props.clearCache(lodash_1.default.get(node, parentField));
-            // if (node && node.children) {
-            //     _.set(tree, rootPath + `[${idx}]`, { ...data, children: node.children });
-            // } else {
-            lodash_1.default.set(tree, rootPath + `[${idx}]`, data);
-            // }
-            setTreeData(tree);
-        }
-    }), [treeState.treeData]);
-    const del = (0, react_1.useCallback)((node, position) => __awaiter(void 0, void 0, void 0, function* () {
-        if (position.length <= 0)
-            return;
-        const root = lodash_1.default.concat([], position);
-        root.pop();
-        let rootPath = '';
-        let arr;
-        const { idForApiField } = props;
-        const { keyField, parentField, titleField, treeData, } = treeState;
-        const { api, objectName } = action;
-        if (root.length == 0) {
-            arr = lodash_1.default.concat([], treeData);
-        }
-        else {
-            let nodePath = root.map(i => `[${i}]`).join('.children');
-            rootPath = nodePath + '.children';
-            arr = lodash_1.default.concat([], lodash_1.default.get(treeData, rootPath));
-        }
-        const resp = yield utils_1.Ajax.DELETE(api, { ids: node[idForApiField || keyField] });
-        if (resp.code != '0') {
-            antd_1.message.error(txt(Const_1.V.ACT_DELETE_FAIL_NAMED, `${objectName} : ${node[titleField]}`));
-            return;
-        }
-        props.clearCache(node[parentField]);
-        let tree = lodash_1.default.concat([], treeData);
-        if (rootPath) {
-            lodash_1.default.set(tree, rootPath, utils_1.ArrayUtil.del(lodash_1.default.get(tree, rootPath), node[keyField], keyField));
-        }
-        else {
-            tree = utils_1.ArrayUtil.del(tree, node[keyField], keyField);
-        }
-        setTreeData(tree);
-        antd_1.message.success(txt(Const_1.V.ACT_DELETE_SUCCESS_NAMED, `${objectName} : ${node[titleField]}`));
-    }), [treeState]);
-    const up = (node, position) => __awaiter(void 0, void 0, void 0, function* () {
-        if (position.length <= 0)
-            return;
-        let root = lodash_1.default.concat([], position);
-        const { parentField, keyField, sortField, treeData } = treeState;
-        const { api, idForApiField } = props;
-        const idField = idForApiField || keyField;
-        let idx = root.pop();
-        if (idx <= 0)
-            return;
-        let rootPath = '';
-        let arr;
-        if (root.length == 0) {
-            arr = lodash_1.default.concat([], treeData);
-        }
-        else {
-            let nodePath = root.map(i => `[${i}]`).join('.children');
-            rootPath = nodePath + '.children';
-            arr = lodash_1.default.concat([], lodash_1.default.get(treeData, rootPath));
-        }
-        var current = arr[idx][sortField];
-        var swap = arr[idx - 1][sortField];
-        arr[idx][sortField] = swap;
-        arr[idx - 1][sortField] = current;
-        let tree = lodash_1.default.concat([], treeData);
-        const resp = yield utils_1.Ajax.WHEN(utils_1.Ajax.PATCH(api, { [idField]: arr[idx][idField], [sortField]: swap }), utils_1.Ajax.PATCH(api, { [idField]: arr[idx - 1][idField], [sortField]: current }));
-        if (resp[0].code != '0' || resp[1].code != '0') {
-            antd_1.message.error(txt(Const_1.V.TREE_SORT_FAIL));
-            return;
-        }
-        props.clearCache(node[parentField]);
-        if (rootPath) {
-            lodash_1.default.set(tree, rootPath, lodash_1.default.orderBy(arr, sortField, 'asc'));
-        }
-        else {
-            tree = lodash_1.default.orderBy(tree, sortField, 'asc');
-        }
-        setTreeData(tree);
-        antd_1.message.success(txt(Const_1.V.TREE_SORT_SUCCESS));
-    });
-    const down = (node, position) => __awaiter(void 0, void 0, void 0, function* () {
-        if (position.length <= 0)
-            return;
-        const { parentField, keyField, sortField, treeData } = treeState;
-        const { api, idForApiField } = props;
-        const idField = idForApiField || keyField;
-        let root = lodash_1.default.concat([], position);
-        let idx = root.pop();
-        let rootPath = '';
-        let arr;
-        if (root.length == 0) {
-            arr = lodash_1.default.concat([], treeData);
-        }
-        else {
-            let nodePath = root.map(i => `[${i}]`).join('.children');
-            rootPath = nodePath + '.children';
-            arr = lodash_1.default.concat([], lodash_1.default.get(treeData, rootPath));
-        }
-        if (idx >= arr.length - 1)
-            return;
-        var current = arr[idx][sortField];
-        var swap = arr[idx + 1][sortField];
-        arr[idx][sortField] = swap;
-        arr[idx + 1][sortField] = current;
-        let tree = lodash_1.default.concat([], treeData);
-        const resp = yield utils_1.Ajax.WHEN(utils_1.Ajax.PATCH(api, { [idField]: arr[idx][idField], [sortField]: swap }), utils_1.Ajax.PATCH(api, { [idField]: arr[idx + 1][idField], [sortField]: current }));
-        if (resp[0].code != '0' || resp[1].code != '0') {
-            antd_1.message.error(txt(Const_1.V.TREE_SORT_FAIL));
-            return;
-        }
-        props.clearCache(node[parentField]);
-        if (rootPath) {
-            lodash_1.default.set(tree, rootPath, lodash_1.default.orderBy(arr, sortField, 'asc'));
-        }
-        else {
-            tree = lodash_1.default.orderBy(tree, sortField, 'asc');
-        }
-        setTreeData(tree);
-        antd_1.message.success(txt(Const_1.V.TREE_SORT_SUCCESS));
-    });
-    const ADD_TITLE = () => {
-        const { pos, node } = modals.modalState.extra || {};
+    var update = (0, react_1.useCallback)(function (data, position) { return __awaiter(void 0, void 0, void 0, function () {
+        var api, objectName, parentField, titleField, treeData, resp, root, tree, idx, rootPath, nodePath, node;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (position.length == 0)
+                        return [2 /*return*/];
+                    api = action.api, objectName = action.objectName;
+                    parentField = treeState.parentField, titleField = treeState.titleField, treeData = treeState.treeData;
+                    return [4 /*yield*/, utils_1.Ajax.PATCH(api, data)];
+                case 1:
+                    resp = _a.sent();
+                    if (resp.code != '0') {
+                        antd_1.message.error(txt(Const_1.V.ACT_UPDATE_FAIL_NAMED, "".concat(objectName, " : ").concat(data[titleField])));
+                        return [2 /*return*/];
+                    }
+                    root = lodash_1.default.concat([], position);
+                    tree = lodash_1.default.concat([], treeData);
+                    idx = root.pop();
+                    rootPath = '';
+                    if (root.length > 0) {
+                        nodePath = root.map(function (i) { return "[".concat(i, "]"); }).join('.children');
+                        rootPath = nodePath + '.children';
+                    }
+                    antd_1.message.success(txt(Const_1.V.ACT_UPDATE_SUCCESS_NAMED, "".concat(objectName, " : ").concat(data[titleField])));
+                    node = lodash_1.default.get(tree, "".concat(rootPath, "[").concat(idx, "]"));
+                    if (node) {
+                        props.clearCache(lodash_1.default.get(node, parentField));
+                        // if (node && node.children) {
+                        //     _.set(tree, rootPath + `[${idx}]`, { ...data, children: node.children });
+                        // } else {
+                        lodash_1.default.set(tree, rootPath + "[".concat(idx, "]"), data);
+                        // }
+                        setTreeData(tree);
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [treeState.treeData]);
+    var del = (0, react_1.useCallback)(function (node, position) { return __awaiter(void 0, void 0, void 0, function () {
+        var root, rootPath, arr, idForApiField, keyField, parentField, titleField, treeData, api, objectName, nodePath, resp, tree;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (position.length <= 0)
+                        return [2 /*return*/];
+                    root = lodash_1.default.concat([], position);
+                    root.pop();
+                    rootPath = '';
+                    idForApiField = props.idForApiField;
+                    keyField = treeState.keyField, parentField = treeState.parentField, titleField = treeState.titleField, treeData = treeState.treeData;
+                    api = action.api, objectName = action.objectName;
+                    if (root.length == 0) {
+                        arr = lodash_1.default.concat([], treeData);
+                    }
+                    else {
+                        nodePath = root.map(function (i) { return "[".concat(i, "]"); }).join('.children');
+                        rootPath = nodePath + '.children';
+                        arr = lodash_1.default.concat([], lodash_1.default.get(treeData, rootPath));
+                    }
+                    return [4 /*yield*/, utils_1.Ajax.DELETE(api, { ids: node[idForApiField || keyField] })];
+                case 1:
+                    resp = _a.sent();
+                    if (resp.code != '0') {
+                        antd_1.message.error(txt(Const_1.V.ACT_DELETE_FAIL_NAMED, "".concat(objectName, " : ").concat(node[titleField])));
+                        return [2 /*return*/];
+                    }
+                    props.clearCache(node[parentField]);
+                    tree = lodash_1.default.concat([], treeData);
+                    if (rootPath) {
+                        lodash_1.default.set(tree, rootPath, utils_1.ArrayUtil.del(lodash_1.default.get(tree, rootPath), node[keyField], keyField));
+                    }
+                    else {
+                        tree = utils_1.ArrayUtil.del(tree, node[keyField], keyField);
+                    }
+                    setTreeData(tree);
+                    antd_1.message.success(txt(Const_1.V.ACT_DELETE_SUCCESS_NAMED, "".concat(objectName, " : ").concat(node[titleField])));
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [treeState]);
+    var up = function (node, position) { return __awaiter(void 0, void 0, void 0, function () {
+        var root, parentField, keyField, sortField, treeData, api, idForApiField, idField, idx, rootPath, arr, nodePath, current, swap, tree, resp;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (position.length <= 0)
+                        return [2 /*return*/];
+                    root = lodash_1.default.concat([], position);
+                    parentField = treeState.parentField, keyField = treeState.keyField, sortField = treeState.sortField, treeData = treeState.treeData;
+                    api = props.api, idForApiField = props.idForApiField;
+                    idField = idForApiField || keyField;
+                    idx = root.pop();
+                    if (idx <= 0)
+                        return [2 /*return*/];
+                    rootPath = '';
+                    if (root.length == 0) {
+                        arr = lodash_1.default.concat([], treeData);
+                    }
+                    else {
+                        nodePath = root.map(function (i) { return "[".concat(i, "]"); }).join('.children');
+                        rootPath = nodePath + '.children';
+                        arr = lodash_1.default.concat([], lodash_1.default.get(treeData, rootPath));
+                    }
+                    current = arr[idx][sortField];
+                    swap = arr[idx - 1][sortField];
+                    arr[idx][sortField] = swap;
+                    arr[idx - 1][sortField] = current;
+                    tree = lodash_1.default.concat([], treeData);
+                    return [4 /*yield*/, utils_1.Ajax.WHEN(utils_1.Ajax.PATCH(api, (_a = {}, _a[idField] = arr[idx][idField], _a[sortField] = swap, _a)), utils_1.Ajax.PATCH(api, (_b = {}, _b[idField] = arr[idx - 1][idField], _b[sortField] = current, _b)))];
+                case 1:
+                    resp = _c.sent();
+                    if (resp[0].code != '0' || resp[1].code != '0') {
+                        antd_1.message.error(txt(Const_1.V.TREE_SORT_FAIL));
+                        return [2 /*return*/];
+                    }
+                    props.clearCache(node[parentField]);
+                    if (rootPath) {
+                        lodash_1.default.set(tree, rootPath, lodash_1.default.orderBy(arr, sortField, 'asc'));
+                    }
+                    else {
+                        tree = lodash_1.default.orderBy(tree, sortField, 'asc');
+                    }
+                    setTreeData(tree);
+                    antd_1.message.success(txt(Const_1.V.TREE_SORT_SUCCESS));
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    var down = function (node, position) { return __awaiter(void 0, void 0, void 0, function () {
+        var parentField, keyField, sortField, treeData, api, idForApiField, idField, root, idx, rootPath, arr, nodePath, current, swap, tree, resp;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (position.length <= 0)
+                        return [2 /*return*/];
+                    parentField = treeState.parentField, keyField = treeState.keyField, sortField = treeState.sortField, treeData = treeState.treeData;
+                    api = props.api, idForApiField = props.idForApiField;
+                    idField = idForApiField || keyField;
+                    root = lodash_1.default.concat([], position);
+                    idx = root.pop();
+                    rootPath = '';
+                    if (root.length == 0) {
+                        arr = lodash_1.default.concat([], treeData);
+                    }
+                    else {
+                        nodePath = root.map(function (i) { return "[".concat(i, "]"); }).join('.children');
+                        rootPath = nodePath + '.children';
+                        arr = lodash_1.default.concat([], lodash_1.default.get(treeData, rootPath));
+                    }
+                    if (idx >= arr.length - 1)
+                        return [2 /*return*/];
+                    current = arr[idx][sortField];
+                    swap = arr[idx + 1][sortField];
+                    arr[idx][sortField] = swap;
+                    arr[idx + 1][sortField] = current;
+                    tree = lodash_1.default.concat([], treeData);
+                    return [4 /*yield*/, utils_1.Ajax.WHEN(utils_1.Ajax.PATCH(api, (_a = {}, _a[idField] = arr[idx][idField], _a[sortField] = swap, _a)), utils_1.Ajax.PATCH(api, (_b = {}, _b[idField] = arr[idx + 1][idField], _b[sortField] = current, _b)))];
+                case 1:
+                    resp = _c.sent();
+                    if (resp[0].code != '0' || resp[1].code != '0') {
+                        antd_1.message.error(txt(Const_1.V.TREE_SORT_FAIL));
+                        return [2 /*return*/];
+                    }
+                    props.clearCache(node[parentField]);
+                    if (rootPath) {
+                        lodash_1.default.set(tree, rootPath, lodash_1.default.orderBy(arr, sortField, 'asc'));
+                    }
+                    else {
+                        tree = lodash_1.default.orderBy(tree, sortField, 'asc');
+                    }
+                    setTreeData(tree);
+                    antd_1.message.success(txt(Const_1.V.TREE_SORT_SUCCESS));
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    var ADD_TITLE = function () {
+        var _a = modals.modalState.extra || {}, pos = _a.pos, node = _a.node;
         if (!action.canSort) {
             if (pos == INSER_POS.INNER) {
                 return react_1.default.createElement("span", null,
@@ -548,14 +679,14 @@ const _Actiontree = (0, react_1.forwardRef)((props, ref) => {
                     react_1.default.createElement("b", null, action.objectName));
         }
     };
-    return react_1.default.createElement(ActionTreeContext.Provider, { value: { action, showAdd, showEdit, del, up, down, } },
+    return react_1.default.createElement(ActionTreeContext.Provider, { value: { action: action, showAdd: showAdd, showEdit: showEdit, del: del, up: up, down: down, } },
         props.children,
-        react_1.default.createElement(UFormModal_1.UFormModal, Object.assign({ title: modals.modalState.isEdit ? react_1.default.createElement("span", null,
+        react_1.default.createElement(UFormModal_1.UFormModal, __assign({ title: modals.modalState.isEdit ? react_1.default.createElement("span", null,
                 " ",
                 txt(Const_1.V.ACT_UPDATE),
                 action.objectName,
                 " : ",
-                react_1.default.createElement("b", null, treeState.titleField)) : ADD_TITLE() }, modals.modalState.modalProps, { fields: FIELDS.current, default: getDefault(), onOk: data => {
+                react_1.default.createElement("b", null, treeState.titleField)) : ADD_TITLE() }, modals.modalState.modalProps, { fields: FIELDS.current, default: getDefault(), onOk: function (data) {
                 modals.hide();
                 if (modals.modalState.isEdit) {
                     update(data, modals.modalState.extra.position);
@@ -568,53 +699,53 @@ const _Actiontree = (0, react_1.forwardRef)((props, ref) => {
 /**
  * ActionTree 可让一个树具备CRUD的能力
 */
-exports.ActionTree = (0, react_1.forwardRef)((props, ref) => react_1.default.createElement(BaseTree_1.BaseTree, Object.assign({}, props),
-    react_1.default.createElement(_Actiontree, Object.assign({}, props, { ref: ref }))));
-const getActionParam = (node, position, state, search, disabledNode, folderChecker, context, parentLen) => {
-    const param = (0, BaseTree_1.getNodeParam)(node, position, state, search, disabledNode, folderChecker);
-    const isRoot = position.length == 1;
+exports.ActionTree = (0, react_1.forwardRef)(function (props, ref) { return react_1.default.createElement(BaseTree_1.BaseTree, __assign({}, props),
+    react_1.default.createElement(_Actiontree, __assign({}, props, { ref: ref }))); });
+var getActionParam = function (node, position, state, search, disabledNode, folderChecker, context, parentLen) {
+    var param = (0, BaseTree_1.getNodeParam)(node, position, state, search, disabledNode, folderChecker);
+    var isRoot = position.length == 1;
     if (param.disabled)
         return param;
-    const { action: { canAdd, canAddRoot, canUpdate, canUpdateRoot, canDelete, canDeleteRoot, canSort } } = context;
+    var _a = context.action, canAdd = _a.canAdd, canAddRoot = _a.canAddRoot, canUpdate = _a.canUpdate, canUpdateRoot = _a.canUpdateRoot, canDelete = _a.canDelete, canDeleteRoot = _a.canDeleteRoot, canSort = _a.canSort;
     if (param.selectable === false && (canAdd || canDelete || canSort || canUpdate)) {
         param.selectable = true;
     }
-    const actions = [];
+    var actions = [];
     if (canAdd && (!lodash_1.default.isFunction(folderChecker) || folderChecker(node))) {
         if (!canSort || !canAddRoot && isRoot) {
             actions.push(react_1.default.createElement(Dropdown_1.Dropdown, { trigger: ["click"], menu: {
                     items: [
-                        { label: txt(Const_1.V.TREE_INSERT_INNER), onClick: (evt) => utils_1.PageUtil.stopEvent(evt.domEvent, () => context.showAdd(INSER_POS.INNER, node, position)), key: 'addInner' },
+                        { label: txt(Const_1.V.TREE_INSERT_INNER), onClick: function (evt) { return utils_1.PageUtil.stopEvent(evt.domEvent, function () { return context.showAdd(INSER_POS.INNER, node, position); }); }, key: 'addInner' },
                     ]
                 } },
-                react_1.default.createElement("span", { onClick: (e) => utils_1.PageUtil.stopEvent(e), className: "vicon vicon-plus vicon-clickable", title: txt(Const_1.V.ACT_ADD) + ' ' + txt(Const_1.V.TREE_NODE) })));
+                react_1.default.createElement("span", { onClick: function (e) { return utils_1.PageUtil.stopEvent(e); }, className: "vicon vicon-plus vicon-clickable", title: txt(Const_1.V.ACT_ADD) + ' ' + txt(Const_1.V.TREE_NODE) })));
         }
         else {
             actions.push(react_1.default.createElement(Dropdown_1.Dropdown, { trigger: ["click"], menu: {
                     items: [
-                        { label: txt(Const_1.V.TREE_INSERT_INNER), onClick: (evt) => utils_1.PageUtil.stopEvent(evt.domEvent, () => context.showAdd(INSER_POS.INNER, node, position)), key: 'addInner' },
-                        { label: txt(Const_1.V.TREE_INSERT_BEFORE), onClick: (evt) => utils_1.PageUtil.stopEvent(evt.domEvent, () => context.showAdd(INSER_POS.BEFORE, node, position)), key: 'addBefore' },
-                        { label: txt(Const_1.V.TREE_INSERT_AFTER), onClick: (evt) => utils_1.PageUtil.stopEvent(evt.domEvent, () => context.showAdd(INSER_POS.AFTER, node, position)), key: 'addAfter' },
+                        { label: txt(Const_1.V.TREE_INSERT_INNER), onClick: function (evt) { return utils_1.PageUtil.stopEvent(evt.domEvent, function () { return context.showAdd(INSER_POS.INNER, node, position); }); }, key: 'addInner' },
+                        { label: txt(Const_1.V.TREE_INSERT_BEFORE), onClick: function (evt) { return utils_1.PageUtil.stopEvent(evt.domEvent, function () { return context.showAdd(INSER_POS.BEFORE, node, position); }); }, key: 'addBefore' },
+                        { label: txt(Const_1.V.TREE_INSERT_AFTER), onClick: function (evt) { return utils_1.PageUtil.stopEvent(evt.domEvent, function () { return context.showAdd(INSER_POS.AFTER, node, position); }); }, key: 'addAfter' },
                     ]
                 } },
-                react_1.default.createElement("span", { onClick: (e) => utils_1.PageUtil.stopEvent(e), className: "vicon vicon-plus vicon-clickable", title: txt(Const_1.V.ACT_ADD) + ' ' + txt(Const_1.V.TREE_NODE) })));
+                react_1.default.createElement("span", { onClick: function (e) { return utils_1.PageUtil.stopEvent(e); }, className: "vicon vicon-plus vicon-clickable", title: txt(Const_1.V.ACT_ADD) + ' ' + txt(Const_1.V.TREE_NODE) })));
         }
     }
     if (canUpdateRoot || (canUpdate && !isRoot)) {
-        actions.push(react_1.default.createElement(Icon_1.Icon, { type: "edit", title: txt(Const_1.V.ACT_UPDATE_TITLE_NAMED, node[state.titleField]), onClick: () => context.showEdit(node, position) }));
+        actions.push(react_1.default.createElement(Icon_1.Icon, { type: "edit", title: txt(Const_1.V.ACT_UPDATE_TITLE_NAMED, node[state.titleField]), onClick: function () { return context.showEdit(node, position); } }));
     }
     if (canSort) {
-        let idx = position[position.length - 1];
+        var idx = position[position.length - 1];
         if (idx > 0) {
-            actions.push(react_1.default.createElement(Icon_1.Icon, { type: "arrow-up", title: txt(Const_1.V.ACT_UPDATE_TITLE_NAMED, node[state.titleField]), onClick: () => context.up(node, position) }));
+            actions.push(react_1.default.createElement(Icon_1.Icon, { type: "arrow-up", title: txt(Const_1.V.ACT_UPDATE_TITLE_NAMED, node[state.titleField]), onClick: function () { return context.up(node, position); } }));
         }
         if (idx < (parentLen - 1)) {
-            actions.push(react_1.default.createElement(Icon_1.Icon, { type: "arrow-down", title: txt(Const_1.V.ACT_UPDATE_TITLE_NAMED, node[state.titleField]), onClick: () => context.down(node, position) }));
+            actions.push(react_1.default.createElement(Icon_1.Icon, { type: "arrow-down", title: txt(Const_1.V.ACT_UPDATE_TITLE_NAMED, node[state.titleField]), onClick: function () { return context.down(node, position); } }));
         }
     }
     if (canDelete && (!isRoot || canDeleteRoot)) {
-        actions.push(react_1.default.createElement(Popconfirm_1.Popconfirm, { onConfirm: () => context.del(node, position), title: txt(Const_1.V.ACT_DELETE_CONFIRM, node[state.titleField]) },
-            react_1.default.createElement("span", { onClick: (e) => utils_1.PageUtil.stopEvent(e), className: "vicon vicon-delete vicon-clickable", title: txt(Const_1.V.ACT_DELETE) + ' ' + node[state.titleField] })));
+        actions.push(react_1.default.createElement(Popconfirm_1.Popconfirm, { onConfirm: function () { return context.del(node, position); }, title: txt(Const_1.V.ACT_DELETE_CONFIRM, node[state.titleField]) },
+            react_1.default.createElement("span", { onClick: function (e) { return utils_1.PageUtil.stopEvent(e); }, className: "vicon vicon-delete vicon-clickable", title: txt(Const_1.V.ACT_DELETE) + ' ' + node[state.titleField] })));
     }
     if (actions.length) {
         param.title = [param.title, react_1.default.createElement("div", { className: 'c-tree-actions' },
@@ -624,71 +755,71 @@ const getActionParam = (node, position, state, search, disabledNode, folderCheck
     }
     return param;
 };
-const renderNode = (props, node, position, state, search, context, parentLen) => {
+var renderNode = function (props, node, position, state, search, context, parentLen) {
     if (search.keyword && !search.match.has(position.join('-')))
         return utils_1.Const.NONE;
-    const param = getActionParam(node, position, state, search, props.disabledNode, props.folderChecker, context, parentLen);
+    var param = getActionParam(node, position, state, search, props.disabledNode, props.folderChecker, context, parentLen);
     if (lodash_1.default.isArray(node.children) && node.children.length) {
-        return react_1.default.createElement(antd_1.Tree.TreeNode, Object.assign({ isLeaf: false }, param), renderNodes(props, state, node.children, position, search, context));
+        return react_1.default.createElement(antd_1.Tree.TreeNode, __assign({ isLeaf: false }, param), renderNodes(props, state, node.children, position, search, context));
     }
     // @ts-ignore
-    let checkField = props.checkField;
+    var checkField = props.checkField;
     if (lodash_1.default.isString(checkField)) {
         if (!node[checkField]) {
             param.isLeaf = true;
         }
     }
-    return react_1.default.createElement(antd_1.Tree.TreeNode, Object.assign({}, param));
+    return react_1.default.createElement(antd_1.Tree.TreeNode, __assign({}, param));
 };
-const renderNodes = (props, state, data, position, search, context) => data.map((item, idx) => renderNode(props, item, [...position, idx], state, search, context, data.length));
-const renderRoot = (props, state, context) => {
-    const { search, treeData } = state;
+var renderNodes = function (props, state, data, position, search, context) { return data.map(function (item, idx) { return renderNode(props, item, __spreadArray(__spreadArray([], __read(position), false), [idx], false), state, search, context, data.length); }); };
+var renderRoot = function (props, state, context) {
+    var search = state.search, treeData = state.treeData;
     if (search.keyword) {
         if (search.match.size == 0)
             return react_1.default.createElement(antd_1.Tree.TreeNode, { isLeaf: true, title: react_1.default.createElement(antd_1.Empty, { description: txt(Const_1.V.TXT_FIND_NULL, search.word) }), selectable: false, className: "c-tree-empty" });
         return renderNodes(props, state, treeData, [], search, context);
     }
-    const { action: { canAddRoot, canAdd, canSort, objectName } } = context;
+    var _a = context.action, canAddRoot = _a.canAddRoot, canAdd = _a.canAdd, canSort = _a.canSort, objectName = _a.objectName;
     if (canAddRoot) {
         return react_1.default.createElement(react_1.Fragment, null,
-            react_1.default.createElement(antd_1.Tree.TreeNode, { isLeaf: true, className: 'c-tree-add-root', selectable: false, checkable: false, selected: false, title: react_1.default.createElement("a", { onClick: evt => {
+            react_1.default.createElement(antd_1.Tree.TreeNode, { isLeaf: true, className: 'c-tree-add-root', selectable: false, checkable: false, selected: false, title: react_1.default.createElement("a", { onClick: function (evt) {
                         utils_1.PageUtil.stopEvent(evt);
                         context.showAdd(INSER_POS.TOP, null, [0]);
                     } },
                     react_1.default.createElement(Icon_1.Icon, { type: 'plus' }),
-                    canSort ? txt(Const_1.V.TREE_INSERT_TOP, objectName) : `${txt(Const_1.V.ACT_ADD)} ${objectName}`) }),
+                    canSort ? txt(Const_1.V.TREE_INSERT_TOP, objectName) : "".concat(txt(Const_1.V.ACT_ADD), " ").concat(objectName)) }),
             renderNodes(props, state, treeData, [], search, context),
-            canSort && treeData.length > 0 && react_1.default.createElement(antd_1.Tree.TreeNode, { isLeaf: true, className: 'c-tree-add-root', selectable: false, selected: false, checkable: false, expanded: true, title: react_1.default.createElement("a", { onClick: evt => {
+            canSort && treeData.length > 0 && react_1.default.createElement(antd_1.Tree.TreeNode, { isLeaf: true, className: 'c-tree-add-root', selectable: false, selected: false, checkable: false, expanded: true, title: react_1.default.createElement("a", { onClick: function (evt) {
                         utils_1.PageUtil.stopEvent(evt);
                         context.showAdd(INSER_POS.BOTTOM, null, [0]);
                     } },
                     react_1.default.createElement(Icon_1.Icon, { type: 'plus' }),
-                    canSort ? txt(Const_1.V.TREE_INSERT_BOTTOM, objectName) : `${txt(Const_1.V.ACT_ADD)} ${objectName}`) }));
+                    canSort ? txt(Const_1.V.TREE_INSERT_BOTTOM, objectName) : "".concat(txt(Const_1.V.ACT_ADD), " ").concat(objectName)) }));
     }
     else if (canAdd && treeData.length == 1) {
         // 说明 兼容树业务：有些项目技术上使用一个根节点，
         // 当根节点只有一个时，则在业务上认为此节点为固定根节点
-        const param = getActionParam(treeData[0], [0], state, search, props.disabledNode, props.folderChecker, context, 1);
-        const childs = (treeData[0].children || []);
-        return react_1.default.createElement(antd_1.Tree.TreeNode, Object.assign({}, param),
-            react_1.default.createElement(antd_1.Tree.TreeNode, { isLeaf: true, className: 'c-tree-add-root', selectable: false, checkable: false, selected: false, title: react_1.default.createElement("a", { onClick: evt => {
+        var param = getActionParam(treeData[0], [0], state, search, props.disabledNode, props.folderChecker, context, 1);
+        var childs_1 = (treeData[0].children || []);
+        return react_1.default.createElement(antd_1.Tree.TreeNode, __assign({}, param),
+            react_1.default.createElement(antd_1.Tree.TreeNode, { isLeaf: true, className: 'c-tree-add-root', selectable: false, checkable: false, selected: false, title: react_1.default.createElement("a", { onClick: function (evt) {
                         utils_1.PageUtil.stopEvent(evt);
                         context.showAdd(INSER_POS.TOP, null, [0, 0]);
                     } },
                     react_1.default.createElement(Icon_1.Icon, { type: 'plus' }),
                     " ",
-                    (canSort && childs.length > 0) ? txt(Const_1.V.TREE_INSERT_TOP, objectName) : `${txt(Const_1.V.ACT_ADD)} ${objectName}`) }),
-            renderNodes(props, state, childs, [0], search, context),
-            canSort && childs.length > 0 && react_1.default.createElement(antd_1.Tree.TreeNode, { isLeaf: true, className: 'c-tree-add-root', selectable: false, selected: false, checkable: false, expanded: true, title: react_1.default.createElement("a", { onClick: evt => {
+                    (canSort && childs_1.length > 0) ? txt(Const_1.V.TREE_INSERT_TOP, objectName) : "".concat(txt(Const_1.V.ACT_ADD), " ").concat(objectName)) }),
+            renderNodes(props, state, childs_1, [0], search, context),
+            canSort && childs_1.length > 0 && react_1.default.createElement(antd_1.Tree.TreeNode, { isLeaf: true, className: 'c-tree-add-root', selectable: false, selected: false, checkable: false, expanded: true, title: react_1.default.createElement("a", { onClick: function (evt) {
                         utils_1.PageUtil.stopEvent(evt);
-                        context.showAdd(INSER_POS.BOTTOM, null, [0, childs.length - 1]);
-                    } }, canSort ? txt(Const_1.V.TREE_INSERT_BOTTOM, objectName) : `${txt(Const_1.V.ACT_ADD)} ${objectName}`) }));
+                        context.showAdd(INSER_POS.BOTTOM, null, [0, childs_1.length - 1]);
+                    } }, canSort ? txt(Const_1.V.TREE_INSERT_BOTTOM, objectName) : "".concat(txt(Const_1.V.ACT_ADD), " ").concat(objectName)) }));
     }
     return renderNodes(props, state, treeData, [], search, context);
 };
 exports.renderRoot = renderRoot;
-const getResponseList = (resp, sortField) => {
-    let data;
+var getResponseList = function (resp, sortField) {
+    var data;
     if (lodash_1.default.has(resp, 'data')) {
         data = resp.data;
     }