vap1 0.0.1

package/components/Trees/ActionTree.js

@@ -0,0 +1,657 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 INSER_POS;
+(function (INSER_POS) {
+    INSER_POS[INSER_POS["BEFORE"] = 0] = "BEFORE";
+    INSER_POS[INSER_POS["AFTER"] = 1] = "AFTER";
+    INSER_POS[INSER_POS["INNER"] = 2] = "INNER";
+    INSER_POS[INSER_POS["TOP"] = 3] = "TOP";
+    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);
+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)(() => {
+        if (props.formDefault == null)
+            return {};
+        if (lodash_1.default.isPlainObject(props.formDefault))
+            return props.formDefault;
+        if (lodash_1.default.isFunction(props.formDefault))
+            return props.formDefault(treeState.selectedNode);
+        return {};
+    }, [treeState.selectedNode]);
+    const action = {
+        objectName: '',
+        canAdd: false,
+        canAddRoot: false,
+        canUpdate: false,
+        canUpdateRoot: false,
+        canDelete: false,
+        canSort: false,
+        notCache: false,
+    };
+    if (props.notCache)
+        action.notCache = true;
+    action.objectName = utils_1.i18n.getText(props.ik, props.objectName, Const_1.V.TREE_NODE);
+    if (props.api) {
+        action.api = props.api;
+        if (props.canAdd) {
+            action.canAdd = true;
+            if (props.canAddRoot)
+                action.canAddRoot = true;
+        }
+        if (props.canUpdate) {
+            action.canUpdate = true;
+            if (props.canUpdateRoot)
+                action.canUpdateRoot = true;
+        }
+        if (props.canDelete)
+            action.canDelete = true;
+        if (props.canSort && treeState.sortField)
+            action.canSort = true;
+    }
+    (0, react_1.useLayoutEffect)(() => {
+        if (ref != null) {
+            ref.current = {
+                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);
+                    if (node == null) {
+                        antd_1.message.error('No parent found');
+                    }
+                    add(data, { pos: INSER_POS.INNER, node, position });
+                }
+            };
+        }
+    }, [treeState.treeData]);
+    (0, react_1.useLayoutEffect)(() => {
+        if (props.formFields) {
+            FIELDS.current = props.formFields;
+            return;
+        }
+        let fields = [];
+        if (treeState.langs) {
+            treeState.langs.map(({ lang, field }) => {
+                fields.push({ title: `${action.objectName}(${lang})`, field: field });
+            });
+        }
+        else {
+            fields.push({ title: action.objectName, field: treeState.titleField });
+        }
+        FIELDS.current = fields;
+        // ref.current
+    }, []);
+    const showAdd = (pos, node, position) => modals.showAdd({ pos, node, position });
+    const showEdit = (node, position) => modals.showEdit(node, { 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) {
+            }
+            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;
+                }
+            }
+            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);
+                }
+            }
+        }
+        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) => {
+        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 = '';
+        if (root.length > 0) {
+            let nodePath = root.map(i => `[${i}]`).join('.children');
+            rootPath = nodePath + '.children';
+        }
+        let node = lodash_1.default.get(tree, `${rootPath}[${idx}]`);
+        props.clearCache(lodash_1.default.get(node, parentField));
+        lodash_1.default.set(tree, rootPath + `[${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;
+        const idField = idForApiField || keyField;
+        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 delId = node[idField];
+        const resp = yield utils_1.Ajax.DELETE(api, { ids: delId });
+        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), delId, keyField));
+        }
+        else {
+            tree = utils_1.ArrayUtil.del(tree, delId, 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));
+    });
+    return react_1.default.createElement(ActionTreeContext.Provider, { value: {
+            action,
+            showAdd, showEdit, del, up, down,
+        } },
+        props.children,
+        react_1.default.createElement(UFormModal_1.UFormModal, Object.assign({ autoTitle: { field: treeState.titleField, label: action.objectName } }, modals.modalState.modalProps, { fields: FIELDS.current, default: getDefault(), onOk: data => {
+                modals.hide();
+                if (modals.modalState.isEdit) {
+                    update(data, modals.modalState.extra.position);
+                }
+                else {
+                    add(data, modals.modalState.extra);
+                }
+            }, onCancel: modals.hide })));
+});
+/**
+ * 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, context, parentLen) => {
+    const param = (0, BaseTree_1.getNodeParam)(node, position, state, search, disabledNode);
+    const isRoot = position.length == 1;
+    if (param.disabled)
+        return param;
+    const { action: { canAdd, canAddRoot, canUpdate, canUpdateRoot, canDelete, canSort } } = context;
+    const actions = [];
+    if (canAdd) {
+        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' },
+                    ]
+                } },
+                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) })));
+        }
+        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' },
+                    ]
+                } },
+                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) })));
+        }
+    }
+    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) }));
+    }
+    if (canSort) {
+        let 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) }));
+        }
+        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) }));
+        }
+    }
+    if (!isRoot && canDelete) {
+        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] })));
+    }
+    if (actions.length) {
+        param.title = [param.title, react_1.default.createElement("div", { className: 'c-tree-actions' },
+                " ",
+                actions,
+                " ")];
+    }
+    return param;
+};
+const renderNode = (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, 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));
+    }
+    // @ts-ignore
+    let 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));
+};
+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;
+    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;
+    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 => {
+                        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}`) }),
+            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 => {
+                        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}`) }));
+    }
+    else if (canAdd && treeData.length == 1) {
+        // 说明 兼容树业务：有些项目技术上使用一个根节点，
+        // 当根节点只有一个时，则在业务上认为此节点为固定根节点
+        const param = getActionParam(treeData[0], [0], state, search, props.disabledNode, 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 => {
+                        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 => {
+                        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}`) }));
+    }
+    return renderNodes(props, state, treeData, [], search, context);
+};
+exports.renderRoot = renderRoot;
+const getResponseList = (resp, sortField) => {
+    let data;
+    if (lodash_1.default.has(resp, 'data')) {
+        data = resp.data;
+    }
+    else if (lodash_1.default.has(resp, 'list')) {
+        data = resp.list;
+    }
+    else {
+        data = [];
+    }
+    if (lodash_1.default.isArray(data)) {
+        if (sortField) {
+            return lodash_1.default.orderBy(data, sortField, 'asc');
+        }
+        return data;
+    }
+    return [data];
+};
+exports.getResponseList = getResponseList;