vxe-gantt 0.0.2 → 3.0.0-beta.0

package/lib/gantt/src/gantt.js

@@ -1,72 +1,2069 @@
 "use strict";
 
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _vue = require("vue");
 var _comp = require("../../ui/src/comp");
-var _ui = require("../../ui");
+var _core = require("@vxe-ui/core");
 var _xeUtils = _interopRequireDefault(require("xe-utils"));
+var _utils = require("../../ui/src/utils");
+var _dom = require("../../ui/src/dom");
+var _log = require("../../ui/src/log");
+var _ganttView = _interopRequireDefault(require("./gantt-view"));
+var _vxeTable = require("vxe-table");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var getConfig = _core.VxeUI.getConfig,
+  getIcon = _core.VxeUI.getIcon,
+  getI18n = _core.VxeUI.getI18n,
+  commands = _core.VxeUI.commands,
+  globalMixins = _core.VxeUI.globalMixins,
+  createEvent = _core.VxeUI.createEvent,
+  globalEvents = _core.VxeUI.globalEvents,
+  GLOBAL_EVENT_KEYS = _core.VxeUI.GLOBAL_EVENT_KEYS,
+  renderEmptyElement = _core.VxeUI.renderEmptyElement,
+  getSlotVNs = _core.VxeUI.getSlotVNs;
+var tableProps = _vxeTable.VxeTable.props;
+var tableMethods = {};
+var propKeys = Object.keys(tableProps);
+var defaultLayouts = [['Form'], ['Toolbar', 'Top', 'Gantt', 'Bottom', 'Pager']];
+function getTableOns(_vm) {
+  var $listeners = _vm.$listeners,
+    proxyConfig = _vm.proxyConfig,
+    proxyOpts = _vm.proxyOpts;
+  var ons = {};
+  _xeUtils.default.each($listeners, function (cb, type) {
+    ons[type] = function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _vm.$emit.apply(_vm, [type].concat(args));
+    };
+  });
+  if (proxyConfig) {
+    if (proxyOpts.sort) {
+      ons['sort-change'] = _vm.sortChangeEvent;
+      ons['clear-all-sort'] = _vm.clearAllSortEvent;
+    }
+    if (proxyOpts.filter) {
+      ons['filter-change'] = _vm.filterChangeEvent;
+      ons['clear-all-filter'] = _vm.clearAllFilterEvent;
+    }
+  }
+  return ons;
+}
+_xeUtils.default.each(_vxeTable.VxeTable.methods, function (fn, name) {
+  tableMethods[name] = function () {
+    var $xeGantt = this;
+    var $xeTable = $xeGantt.$refs.refTable;
+    return $xeTable && $xeTable[name].apply($xeTable, arguments);
+  };
+});
 function createInternalData() {
-  return {};
+  return {
+    resizeTableWidth: 0
+  };
 }
-var _default = exports.default = (0, _comp.defineVxeComponent)({
+var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defineVxeComponent)({
   name: 'VxeGantt',
-  props: {
+  mixins: [globalMixins.sizeMixin],
+  props: Object.assign(Object.assign({}, tableProps), {
+    columns: Array,
+    pagerConfig: Object,
+    proxyConfig: Object,
+    toolbarConfig: Object,
+    formConfig: Object,
+    zoomConfig: Object,
+    layouts: Array,
+    taskConfig: Object,
+    taskViewConfig: Object,
+    taskBarConfig: Object,
+    taskSplitConfig: Object,
     size: {
       type: String,
-      default: () => (0, _ui.getConfig)().gantt.size || (0, _ui.getConfig)().size
+      default: function _default() {
+        return getConfig().gantt.size || getConfig().size;
+      }
     }
+  }),
+  provide: function provide() {
+    var $xeGantt = this;
+    return {
+      $xeGantt: $xeGantt
+    };
   },
-  emits: [],
-  setup(props, context) {
-    const {
-      emit
-    } = context;
-    const xID = _xeUtils.default.uniqueId();
-    const refElem = (0, _vue.ref)();
-    const refTable = (0, _vue.ref)();
-    const reactData = (0, _vue.reactive)({});
-    const internalData = createInternalData();
-    const refMaps = {
-      refElem,
-      refTable
+  data: function data() {
+    var _a;
+    var xID = _xeUtils.default.uniqueId();
+    var reactData = {
+      tableLoading: false,
+      proxyInited: false,
+      isZMax: false,
+      tableData: [],
+      filterData: [],
+      formData: {},
+      sortData: [],
+      tZindex: 0,
+      tablePage: {
+        total: 0,
+        pageSize: ((_a = getConfig().pager) === null || _a === void 0 ? void 0 : _a.pageSize) || 10,
+        currentPage: 1
+      },
+      showLeftView: true,
+      showRightView: true
     };
-    const computeMaps = {};
-    const $xeGantt = {
-      xID,
-      props,
-      context,
-      reactData,
-      internalData,
-      getRefMaps: () => refMaps,
-      getComputeMaps: () => computeMaps
+    var internalData = createInternalData();
+    return {
+      xID: xID,
+      reactData: reactData,
+      internalData: internalData
     };
-    const dispatchEvent = (type, params, evnt) => {
-      emit(type, (0, _ui.createEvent)(evnt, {
+  },
+  computed: Object.assign(Object.assign({}, {}), {
+    computeProxyOpts: function computeProxyOpts() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return _xeUtils.default.merge({}, _xeUtils.default.clone(getConfig().gantt.proxyConfig, true), props.proxyConfig);
+    },
+    computeIsRespMsg: function computeIsRespMsg() {
+      var $xeGantt = this;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      return !!(_xeUtils.default.isBoolean(proxyOpts.message) ? proxyOpts.message : proxyOpts.showResponseMsg);
+    },
+    computeIsActiveMsg: function computeIsActiveMsg() {
+      var $xeGantt = this;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      return _xeUtils.default.isBoolean(proxyOpts.showActionMsg) ? proxyOpts.showActionMsg : !!proxyOpts.showActiveMsg;
+    },
+    computePagerOpts: function computePagerOpts() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return Object.assign({}, getConfig().gantt.pagerConfig, props.pagerConfig);
+    },
+    computeFormOpts: function computeFormOpts() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return Object.assign({}, getConfig().gantt.formConfig, props.formConfig);
+    },
+    computeToolbarOpts: function computeToolbarOpts() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return Object.assign({}, getConfig().gantt.toolbarConfig, props.toolbarConfig);
+    },
+    computeZoomOpts: function computeZoomOpts() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return Object.assign({}, getConfig().gantt.zoomConfig, props.zoomConfig);
+    },
+    computeTaskOpts: function computeTaskOpts() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return Object.assign({}, getConfig().gantt.taskConfig, props.taskConfig);
+    },
+    computeTaskViewOpts: function computeTaskViewOpts() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return Object.assign({}, getConfig().gantt.taskViewConfig, props.taskViewConfig);
+    },
+    computeTaskBarOpts: function computeTaskBarOpts() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return Object.assign({}, getConfig().gantt.taskBarConfig, props.taskBarConfig);
+    },
+    computeTaskSplitOpts: function computeTaskSplitOpts() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return Object.assign({}, getConfig().gantt.taskSplitConfig, props.taskSplitConfig);
+    },
+    computeTitleField: function computeTitleField() {
+      var $xeGantt = this;
+      var taskOpts = $xeGantt.computeTaskOpts;
+      return taskOpts.titleField || 'title';
+    },
+    computeStartField: function computeStartField() {
+      var $xeGantt = this;
+      var taskOpts = $xeGantt.computeTaskOpts;
+      return taskOpts.startField || 'start';
+    },
+    computeEndField: function computeEndField() {
+      var $xeGantt = this;
+      var taskOpts = $xeGantt.computeTaskOpts;
+      return taskOpts.endField || 'end';
+    },
+    computeProgressField: function computeProgressField() {
+      var $xeGantt = this;
+      var taskOpts = $xeGantt.computeTaskOpts;
+      return taskOpts.progressField || 'progress';
+    },
+    computeScrollbarOpts: function computeScrollbarOpts() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return Object.assign({}, getConfig().gantt.scrollbarConfig, props.scrollbarConfig);
+    },
+    computeScrollbarXToTop: function computeScrollbarXToTop() {
+      var $xeGantt = this;
+      var scrollbarOpts = $xeGantt.computeScrollbarOpts;
+      return !!(scrollbarOpts.x && scrollbarOpts.x.position === 'top');
+    },
+    computeScrollbarYToLeft: function computeScrollbarYToLeft() {
+      var $xeGantt = this;
+      var scrollbarOpts = $xeGantt.computeScrollbarOpts;
+      return !!(scrollbarOpts.y && scrollbarOpts.y.position === 'left');
+    },
+    computeStyles: function computeStyles() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var height = props.height,
+        maxHeight = props.maxHeight;
+      var isZMax = reactData.isZMax,
+        tZindex = reactData.tZindex;
+      var taskViewOpts = $xeGantt.computeTaskViewOpts;
+      var tableStyle = taskViewOpts.tableStyle;
+      var taskBarOpts = $xeGantt.computeTaskBarOpts;
+      var barStyle = taskBarOpts.barStyle;
+      var stys = {};
+      if (isZMax) {
+        stys.zIndex = tZindex;
+      } else {
+        if (height) {
+          stys.height = height === 'auto' || height === '100%' ? '100%' : (0, _dom.toCssUnit)(height);
+        }
+        if (maxHeight) {
+          stys.maxHeight = maxHeight === 'auto' || maxHeight === '100%' ? '100%' : (0, _dom.toCssUnit)(maxHeight);
+        }
+      }
+      if (barStyle) {
+        var bgColor = barStyle.bgColor,
+          completedBgColor = barStyle.completedBgColor;
+        if (bgColor) {
+          stys['--vxe-ui-gantt-view-task-bar-background-color'] = bgColor;
+        }
+        if (completedBgColor) {
+          stys['--vxe-ui-gantt-view-task-bar-completed-background-color'] = completedBgColor;
+        }
+      }
+      if (tableStyle) {
+        var defTbWidth = tableStyle.width;
+        if (defTbWidth) {
+          stys['--vxe-ui-gantt-view-table-default-width'] = (0, _dom.toCssUnit)(defTbWidth);
+        }
+      }
+      return stys;
+    },
+    computeTableExtendProps: function computeTableExtendProps() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var rest = {};
+      var gridProps = props;
+      propKeys.forEach(function (key) {
+        rest[key] = gridProps[key];
+      });
+      return rest;
+    },
+    computeTableProps: function computeTableProps() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var seqConfig = props.seqConfig,
+        pagerConfig = props.pagerConfig,
+        editConfig = props.editConfig,
+        proxyConfig = props.proxyConfig;
+      var isZMax = reactData.isZMax,
+        tablePage = reactData.tablePage;
+      var tableExtendProps = $xeGantt.computeTableExtendProps;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      var pagerOpts = $xeGantt.computePagerOpts;
+      var isLoading = $xeGantt.computeIsLoading;
+      var tProps = Object.assign({}, tableExtendProps);
+      if (isZMax) {
+        if (tableExtendProps.maxHeight) {
+          tProps.maxHeight = '100%';
+        } else {
+          tProps.height = '100%';
+        }
+      }
+      if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
+        tProps.loading = isLoading;
+        if (pagerConfig && proxyOpts.seq && (0, _utils.isEnableConf)(pagerOpts)) {
+          tProps.seqConfig = Object.assign({}, seqConfig, {
+            startIndex: (tablePage.currentPage - 1) * tablePage.pageSize
+          });
+        }
+      }
+      if (editConfig) {
+        tProps.editConfig = Object.assign({}, editConfig);
+      }
+      return tProps;
+    },
+    tableProps: function tableProps() {
+      var $xeGantt = this;
+      return $xeGantt.computeTableProps;
+    },
+    computeCurrLayoutConf: function computeCurrLayoutConf() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var layouts = props.layouts;
+      var confs = [];
+      if (layouts && layouts.length) {
+        confs = layouts;
+      } else {
+        confs = getConfig().gantt.layouts || defaultLayouts;
+      }
+      var headKeys = [];
+      var bodyKeys = [];
+      var footKeys = [];
+      if (confs.length) {
+        if (_xeUtils.default.isArray(confs[0])) {
+          headKeys = confs[0];
+          bodyKeys = confs[1] || [];
+          footKeys = confs[2] || [];
+        } else {
+          bodyKeys = confs;
+        }
+      }
+      return {
+        headKeys: headKeys,
+        bodyKeys: bodyKeys,
+        footKeys: footKeys
+      };
+    },
+    computeCustomCurrentPageFlag: function computeCustomCurrentPageFlag() {
+      var $xeGantt = this;
+      var pagerOpts = $xeGantt.computePagerOpts;
+      return pagerOpts.currentPage;
+    },
+    computeCustomPageSizeFlag: function computeCustomPageSizeFlag() {
+      var $xeGantt = this;
+      var pagerOpts = $xeGantt.computePagerOpts;
+      return pagerOpts.pageSize;
+    },
+    computeCustomTotalFlag: function computeCustomTotalFlag() {
+      var $xeGantt = this;
+      var pagerOpts = $xeGantt.computePagerOpts;
+      return pagerOpts.total;
+    },
+    computePageCount: function computePageCount() {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      var tablePage = reactData.tablePage;
+      return Math.max(Math.ceil(tablePage.total / tablePage.pageSize), 1);
+    },
+    computeIsLoading: function computeIsLoading() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var loading = props.loading,
+        proxyConfig = props.proxyConfig;
+      var tableLoading = reactData.tableLoading;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      var showLoading = proxyOpts.showLoading;
+      return loading || tableLoading && showLoading && proxyConfig && (0, _utils.isEnableConf)(proxyOpts);
+    },
+    computeTableBorder: function computeTableBorder() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var border = props.border;
+      if (border === true) {
+        return 'full';
+      }
+      if (border) {
+        return border;
+      }
+      return 'default';
+    }
+  }),
+  watch: {
+    columns: function columns() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      $xeGantt.$nextTick(function () {
+        return $xeGantt.loadColumn(props.columns || []);
+      });
+    },
+    toolbarConfig: function toolbarConfig() {
+      var $xeGantt = this;
+      $xeGantt.initToolbar();
+    },
+    computeCustomCurrentPageFlag: function computeCustomCurrentPageFlag() {
+      var $xeGantt = this;
+      $xeGantt.initPages('currentPage');
+    },
+    computeCustomPageSizeFlag: function computeCustomPageSizeFlag() {
+      var $xeGantt = this;
+      $xeGantt.initPages('pageSize');
+    },
+    computeCustomTotalFlag: function computeCustomTotalFlag() {
+      var $xeGantt = this;
+      $xeGantt.initPages('total');
+    },
+    proxyConfig: function proxyConfig() {
+      var $xeGantt = this;
+      $xeGantt.initProxy();
+    }
+  },
+  methods: Object.assign(Object.assign({}, tableMethods), {
+    dispatchEvent: function dispatchEvent(type, params, evnt) {
+      var $xeGantt = this;
+      $xeGantt.$emit(type, createEvent(evnt, {
+        $grid: null,
         $gantt: $xeGantt
       }, params));
-    };
-    const ganttMethods = {
-      dispatchEvent
-    };
-    const ganttPrivateMethods = {};
-    Object.assign($xeGantt, ganttMethods, ganttPrivateMethods);
-    const renderVN = () => {
-      return (0, _vue.h)('div', {
-        ref: refElem,
-        class: 'vxe-gantt'
+    },
+    initToolbar: function initToolbar() {
+      var $xeGantt = this;
+      $xeGantt.$nextTick(function () {
+        var $xeTable = $xeGantt.$refs.refTable;
+        var $xeToolbar = $xeGantt.$refs.refToolbar;
+        if ($xeTable && $xeToolbar) {
+          $xeTable.connectToolbar($xeToolbar);
+        }
       });
-    };
-    (0, _vue.onUnmounted)(() => {
-      _xeUtils.default.assign(internalData, createInternalData());
+    },
+    initGanttView: function initGanttView() {
+      var $xeGantt = this;
+      var $xeTable = $xeGantt.$refs.refTable;
+      var $ganttView = $xeGantt.$refs.refGanttView;
+      if ($xeTable && $ganttView) {
+        $xeTable.handleConnectGanttView($ganttView);
+      }
+    },
+    initPages: function initPages(propKey) {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var tablePage = reactData.tablePage;
+      var pagerConfig = props.pagerConfig;
+      var pagerOpts = $xeGantt.computePagerOpts;
+      if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts)) {
+        if (propKey) {
+          if (pagerOpts[propKey]) {
+            tablePage[propKey] = _xeUtils.default.toNumber(pagerOpts[propKey]);
+          }
+        } else {
+          var currentPage = pagerOpts.currentPage,
+            pageSize = pagerOpts.pageSize,
+            total = pagerOpts.total;
+          if (currentPage) {
+            tablePage.currentPage = currentPage;
+          }
+          if (pageSize) {
+            tablePage.pageSize = pageSize;
+          }
+          if (total) {
+            tablePage.total = total;
+          }
+        }
+      }
+    },
+    triggerPendingEvent: function triggerPendingEvent(code) {
+      var $xeGantt = this;
+      var isActiveMsg = $xeGantt.computeIsActiveMsg;
+      var $xeTable = $xeGantt.$refs.refTable;
+      var selectRecords = $xeTable.getCheckboxRecords();
+      if (selectRecords.length) {
+        $xeTable.togglePendingRow(selectRecords);
+        $xeGantt.clearCheckboxRow();
+      } else {
+        if (isActiveMsg) {
+          if (_core.VxeUI.modal) {
+            _core.VxeUI.modal.message({
+              id: code,
+              content: getI18n('vxe.grid.selectOneRecord'),
+              status: 'warning'
+            });
+          }
+        }
+      }
+    },
+    getRespMsg: function getRespMsg(rest, defaultMsg) {
+      var $xeGantt = this;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      var resConfigs = proxyOpts.response || proxyOpts.props || {};
+      var messageProp = resConfigs.message;
+      var $xeTable = $xeGantt.$refs.refTable;
+      var msg;
+      if (rest && messageProp) {
+        msg = _xeUtils.default.isFunction(messageProp) ? messageProp({
+          data: rest,
+          $table: $xeTable,
+          $grid: null,
+          $gantt: $xeGantt
+        }) : _xeUtils.default.get(rest, messageProp);
+      }
+      return msg || getI18n(defaultMsg);
+    },
+    handleDeleteRow: function handleDeleteRow(code, alertKey, callback) {
+      var $xeGantt = this;
+      var isActiveMsg = $xeGantt.computeIsActiveMsg;
+      var selectRecords = $xeGantt.getCheckboxRecords();
+      if (isActiveMsg) {
+        if (selectRecords.length) {
+          if (_core.VxeUI.modal) {
+            return _core.VxeUI.modal.confirm({
+              id: "cfm_".concat(code),
+              content: getI18n(alertKey),
+              escClosable: true
+            }).then(function (type) {
+              if (type === 'confirm') {
+                return callback();
+              }
+            });
+          }
+        } else {
+          if (_core.VxeUI.modal) {
+            _core.VxeUI.modal.message({
+              id: "msg_".concat(code),
+              content: getI18n('vxe.grid.selectOneRecord'),
+              status: 'warning'
+            });
+          }
+        }
+      } else {
+        if (selectRecords.length) {
+          callback();
+        }
+      }
+      return Promise.resolve();
+    },
+    pageChangeEvent: function pageChangeEvent(params) {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var proxyConfig = props.proxyConfig;
+      var tablePage = reactData.tablePage;
+      var $event = params.$event,
+        currentPage = params.currentPage,
+        pageSize = params.pageSize;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      tablePage.currentPage = currentPage;
+      tablePage.pageSize = pageSize;
+      $xeGantt.dispatchEvent('page-change', params, $event);
+      if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
+        $xeGantt.commitProxy('query').then(function (rest) {
+          $xeGantt.dispatchEvent('proxy-query', rest, $event);
+        });
+      }
+    },
+    handleSortEvent: function handleSortEvent(params) {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var $xeTable = $xeGantt.$refs.refTable;
+      var proxyConfig = props.proxyConfig;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      var sortOpts = $xeTable.computeSortOpts;
+      // 如果是服务端排序
+      if (sortOpts.remote) {
+        reactData.sortData = params.sortList;
+        if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
+          reactData.tablePage.currentPage = 1;
+          $xeGantt.commitProxy('query').then(function (rest) {
+            $xeGantt.dispatchEvent('proxy-query', rest, params.$event);
+          });
+        }
+      }
+    },
+    sortChangeEvent: function sortChangeEvent(params) {
+      var $xeGantt = this;
+      $xeGantt.handleSortEvent(params);
+      $xeGantt.dispatchEvent('sort-change', params, params.$event);
+    },
+    clearAllSortEvent: function clearAllSortEvent(params) {
+      var $xeGantt = this;
+      $xeGantt.handleSortEvent(params);
+      $xeGantt.dispatchEvent('clear-all-sort', params, params.$event);
+    },
+    handleFilterEvent: function handleFilterEvent(params) {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var $xeTable = $xeGantt.$refs.refTable;
+      var proxyConfig = props.proxyConfig;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      var filterOpts = $xeTable.computeFilterOpts;
+      // 如果是服务端过滤
+      if (filterOpts.remote) {
+        reactData.filterData = params.filterList;
+        if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
+          reactData.tablePage.currentPage = 1;
+          $xeGantt.commitProxy('query').then(function (rest) {
+            $xeGantt.dispatchEvent('proxy-query', rest, params.$event);
+          });
+        }
+      }
+    },
+    filterChangeEvent: function filterChangeEvent(params) {
+      var $xeGantt = this;
+      $xeGantt.handleFilterEvent(params);
+      $xeGantt.dispatchEvent('filter-change', params, params.$event);
+    },
+    clearAllFilterEvent: function clearAllFilterEvent(params) {
+      var $xeGantt = this;
+      $xeGantt.handleFilterEvent(params);
+      $xeGantt.dispatchEvent('clear-all-filter', params, params.$event);
+    },
+    submitFormEvent: function submitFormEvent(params) {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var proxyConfig = props.proxyConfig;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      if (reactData.tableLoading) {
+        return;
+      }
+      if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
+        $xeGantt.commitProxy('reload').then(function (rest) {
+          $xeGantt.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), {
+            isReload: true
+          }), params.$event);
+        });
+      }
+      $xeGantt.dispatchEvent('form-submit', params, params.$event);
+    },
+    resetFormEvent: function resetFormEvent(params) {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var $xeTable = $xeGantt.$refs.refTable;
+      var proxyConfig = props.proxyConfig;
+      var $event = params.$event;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
+        $xeTable.clearScroll();
+        $xeGantt.commitProxy('reload').then(function (rest) {
+          $xeGantt.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), {
+            isReload: true
+          }), $event);
+        });
+      }
+      $xeGantt.dispatchEvent('form-reset', params, $event);
+    },
+    submitInvalidEvent: function submitInvalidEvent(params) {
+      var $xeGantt = this;
+      $xeGantt.dispatchEvent('form-submit-invalid', params, params.$event);
+    },
+    collapseEvent: function collapseEvent(params) {
+      var $xeGantt = this;
+      var $event = params.$event;
+      $xeGantt.dispatchEvent('form-toggle-collapse', params, $event);
+      $xeGantt.dispatchEvent('form-collapse', params, $event);
+    },
+    handleZoom: function handleZoom(isMax) {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      var isZMax = reactData.isZMax;
+      if (isMax ? !isZMax : isZMax) {
+        reactData.isZMax = !isZMax;
+        if (reactData.tZindex < (0, _utils.getLastZIndex)()) {
+          reactData.tZindex = (0, _utils.nextZIndex)();
+        }
+      }
+      return $xeGantt.$nextTick().then(function () {
+        return $xeGantt.recalculate(true);
+      }).then(function () {
+        setTimeout(function () {
+          return $xeGantt.recalculate(true);
+        }, 15);
+        return reactData.isZMax;
+      });
+    },
+    dragSplitEvent: function dragSplitEvent(evnt) {
+      var $xeGantt = this;
+      var el = $xeGantt.$refs.refElem;
+      if (!el) {
+        return;
+      }
+      var ganttContainerEl = $xeGantt.$refs.refGanttContainer;
+      if (!ganttContainerEl) {
+        return;
+      }
+      var tableWrapperEl = $xeGantt.$refs.refTableWrapper;
+      if (!tableWrapperEl) {
+        return;
+      }
+      var rsSplitLineEl = $xeGantt.$refs.refResizableSplitTip;
+      if (!rsSplitLineEl) {
+        return;
+      }
+      var taskViewOpts = $xeGantt.computeTaskViewOpts;
+      var containerRect = ganttContainerEl.getBoundingClientRect();
+      var rsSplitTipEl = rsSplitLineEl.children[0];
+      var disX = evnt.clientX;
+      var ganttWidth = ganttContainerEl.clientWidth;
+      var tableWidth = tableWrapperEl.clientWidth;
+      var tableMinWidth = taskViewOpts.tableStyle && _xeUtils.default.toNumber(taskViewOpts.tableStyle.minWidth) || 80;
+      var targetTableWidth = tableWidth;
+      var offsetLeft = -1;
+      (0, _dom.addClass)(el, 'is--split-drag');
+      var handleReStyle = function handleReStyle(evnt) {
+        var rsNumLeftEl = rsSplitTipEl.children[0];
+        var rsNumRightEl = rsSplitTipEl.children[1];
+        var tipHeight = 0;
+        if (rsNumLeftEl) {
+          if (offsetLeft < 0) {
+            rsNumLeftEl.textContent = "".concat(targetTableWidth, "px");
+            rsNumLeftEl.style.display = 'block';
+            tipHeight = rsNumLeftEl.offsetHeight;
+          } else {
+            rsNumLeftEl.style.display = 'none';
+          }
+        }
+        if (rsNumRightEl) {
+          if (offsetLeft < 0) {
+            rsNumRightEl.style.display = 'none';
+          } else {
+            rsNumRightEl.textContent = "".concat(Math.floor(containerRect.width - targetTableWidth), "px");
+            rsNumRightEl.style.display = 'block';
+            tipHeight = rsNumRightEl.offsetHeight;
+          }
+        }
+        var tipTop = evnt.clientY - containerRect.top - tipHeight / 2;
+        rsSplitLineEl.style.left = "".concat(targetTableWidth, "px");
+        rsSplitTipEl.style.top = "".concat(Math.min(containerRect.height - tipHeight - 1, Math.max(1, tipTop)), "px");
+      };
+      document.onmousemove = function (evnt) {
+        evnt.preventDefault();
+        offsetLeft = evnt.clientX - disX;
+        targetTableWidth = Math.min(ganttWidth - 80, Math.max(tableMinWidth, tableWidth + offsetLeft));
+        handleReStyle(evnt);
+      };
+      document.onmouseup = function () {
+        document.onmousemove = null;
+        document.onmouseup = null;
+        rsSplitLineEl.style.display = '';
+        tableWrapperEl.style.width = "".concat(targetTableWidth, "px");
+        (0, _dom.removeClass)(el, 'is--split-drag');
+        var $xeTable = $xeGantt.$refs.refTable;
+        if ($xeTable) {
+          $xeTable.recalculate(true);
+        }
+      };
+      rsSplitLineEl.style.display = 'block';
+      handleReStyle(evnt);
+    },
+    handleSplitLeftViewEvent: function handleSplitLeftViewEvent() {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      reactData.showLeftView = !reactData.showLeftView;
+    },
+    handleSplitRightViewEvent: function handleSplitRightViewEvent() {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      reactData.showRightView = !reactData.showRightView;
+    },
+    getDefaultFormData: function getDefaultFormData() {
+      var $xeGantt = this;
+      var formOpts = $xeGantt.computeFormOpts;
+      if (formOpts.items) {
+        var fData = {};
+        formOpts.items.forEach(function (item) {
+          var field = item.field,
+            itemRender = item.itemRender;
+          if (field) {
+            var itemValue = null;
+            if (itemRender) {
+              var defaultValue = itemRender.defaultValue;
+              if (_xeUtils.default.isFunction(defaultValue)) {
+                itemValue = defaultValue({
+                  item: item
+                });
+              } else if (!_xeUtils.default.isUndefined(defaultValue)) {
+                itemValue = defaultValue;
+              }
+            }
+            fData[field] = itemValue;
+          }
+        });
+        return fData;
+      }
+      return {};
+    },
+    initProxy: function initProxy() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var proxyConfig = props.proxyConfig,
+        formConfig = props.formConfig;
+      var proxyInited = reactData.proxyInited;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      var formOpts = $xeGantt.computeFormOpts;
+      if (proxyConfig) {
+        if ((0, _utils.isEnableConf)(formConfig) && proxyOpts.form && formOpts.items) {
+          reactData.formData = $xeGantt.getDefaultFormData();
+        }
+        if (!proxyInited && proxyOpts.autoLoad !== false) {
+          reactData.proxyInited = true;
+          $xeGantt.$nextTick().then(function () {
+            return $xeGantt.commitProxy('initial');
+          }).then(function (rest) {
+            $xeGantt.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), {
+              isInited: true
+            }), new Event('initial'));
+          });
+        }
+      }
+    },
+    handleGlobalKeydownEvent: function handleGlobalKeydownEvent(evnt) {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      var zoomOpts = $xeGantt.computeZoomOpts;
+      var isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+      if (isEsc && reactData.isZMax && zoomOpts.escRestore !== false) {
+        $xeGantt.triggerZoomEvent(evnt);
+      }
+    },
+    getEl: function getEl() {
+      var $xeGantt = this;
+      return $xeGantt.$refs.refElem;
+    },
+    /**
+       * 提交指令，支持 code 或 button
+       * @param {String/Object} code 字符串或对象
+       */
+    commitProxy: function commitProxy(proxyTarget) {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      /**
+       * 已废弃
+       * @deprecated
+       */
+      var toolbar = props.toolbar;
+      var proxyConfig = props.proxyConfig,
+        toolbarConfig = props.toolbarConfig,
+        pagerConfig = props.pagerConfig,
+        editRules = props.editRules,
+        validConfig = props.validConfig;
+      var tablePage = reactData.tablePage;
+      var isActiveMsg = $xeGantt.computeIsActiveMsg;
+      var isRespMsg = $xeGantt.computeIsRespMsg;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      var pagerOpts = $xeGantt.computePagerOpts;
+      var toolbarOpts = $xeGantt.computeToolbarOpts;
+      var beforeQuery = proxyOpts.beforeQuery,
+        afterQuery = proxyOpts.afterQuery,
+        beforeDelete = proxyOpts.beforeDelete,
+        afterDelete = proxyOpts.afterDelete,
+        beforeSave = proxyOpts.beforeSave,
+        afterSave = proxyOpts.afterSave,
+        _proxyOpts$ajax = proxyOpts.ajax,
+        ajax = _proxyOpts$ajax === void 0 ? {} : _proxyOpts$ajax;
+      var resConfigs = proxyOpts.response || proxyOpts.props || {};
+      var $xeTable = $xeGantt.$refs.refTable;
+      var formData = $xeGantt.getFormData();
+      var button = null;
+      var code = null;
+      if (_xeUtils.default.isString(proxyTarget)) {
+        var buttons = toolbarOpts.buttons;
+        var matchObj = (toolbarConfig || toolbar) && (0, _utils.isEnableConf)(toolbarOpts) && buttons ? _xeUtils.default.findTree(buttons, function (item) {
+          return item.code === proxyTarget;
+        }, {
+          children: 'dropdowns'
+        }) : null;
+        button = matchObj ? matchObj.item : null;
+        code = proxyTarget;
+      } else {
+        button = proxyTarget;
+        code = button.code;
+      }
+      var btnParams = button ? button.params : null;
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+      switch (code) {
+        case 'insert':
+          return $xeTable.insert({});
+        case 'insert_edit':
+          return $xeTable.insert({}).then(function (_ref) {
+            var row = _ref.row;
+            return $xeTable.setEditRow(row, true);
+          });
+        // 已废弃
+        case 'insert_actived':
+          return $xeTable.insert({}).then(function (_ref2) {
+            var row = _ref2.row;
+            return $xeTable.setEditRow(row, true);
+          });
+        // 已废弃
+        case 'mark_cancel':
+          $xeGantt.triggerPendingEvent(code);
+          break;
+        case 'remove':
+          return $xeGantt.handleDeleteRow(code, 'vxe.grid.removeSelectRecord', function () {
+            return $xeTable.removeCheckboxRow();
+          });
+        case 'import':
+          $xeTable.importData(btnParams);
+          break;
+        case 'open_import':
+          $xeTable.openImport(btnParams);
+          break;
+        case 'export':
+          $xeTable.exportData(btnParams);
+          break;
+        case 'open_export':
+          $xeTable.openExport(btnParams);
+          break;
+        case 'reset_custom':
+          $xeTable.resetCustom(true);
+          break;
+        case 'initial':
+        case 'reload':
+        case 'query':
+          {
+            var ajaxMethods = ajax.query;
+            var querySuccessMethods = ajax.querySuccess;
+            var queryErrorMethods = ajax.queryError;
+            if (ajaxMethods) {
+              var isInited = code === 'initial';
+              var isReload = code === 'reload';
+              if (!isInited && reactData.tableLoading) {
+                return $xeGantt.$nextTick();
+              }
+              var sortList = [];
+              var filterList = [];
+              var pageParams = {};
+              if (pagerConfig) {
+                if (isInited || isReload) {
+                  tablePage.currentPage = 1;
+                }
+                if ((0, _utils.isEnableConf)(pagerConfig)) {
+                  pageParams = Object.assign({}, tablePage);
+                }
+              }
+              if (isInited) {
+                // 重置代理表单数据
+                if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts) && proxyOpts.form) {
+                  formData = $xeGantt.getDefaultFormData();
+                  reactData.formData = formData;
+                }
+                if ($xeTable) {
+                  var tableInternalData = $xeTable;
+                  var tableFullColumn = tableInternalData.tableFullColumn,
+                    fullColumnFieldData = tableInternalData.fullColumnFieldData;
+                  var sortOpts = $xeTable.computeSortOpts;
+                  var defaultSort = sortOpts.defaultSort;
+                  tableFullColumn.forEach(function (column) {
+                    column.order = null;
+                  });
+                  // 如果使用默认排序
+                  if (defaultSort) {
+                    if (!_xeUtils.default.isArray(defaultSort)) {
+                      defaultSort = [defaultSort];
+                    }
+                    sortList = defaultSort.map(function (item) {
+                      var field = item.field,
+                        order = item.order;
+                      var colRest = fullColumnFieldData[field];
+                      if (colRest) {
+                        var column = colRest.column;
+                        if (column) {
+                          column.order = order;
+                        }
+                      }
+                      return {
+                        field: field,
+                        property: field,
+                        order: order
+                      };
+                    });
+                  }
+                  filterList = $xeTable.getCheckedFilters();
+                }
+              } else {
+                if ($xeTable) {
+                  if (isReload) {
+                    $xeTable.clearAll();
+                  } else {
+                    sortList = $xeTable.getSortColumns();
+                    filterList = $xeTable.getCheckedFilters();
+                  }
+                }
+              }
+              var commitParams = {
+                $table: $xeTable,
+                $grid: null,
+                $gantt: $xeGantt,
+                code: code,
+                button: button,
+                isInited: isInited,
+                isReload: isReload,
+                page: pageParams,
+                sort: sortList.length ? sortList[0] : {},
+                sorts: sortList,
+                filters: filterList,
+                form: formData,
+                options: ajaxMethods
+              };
+              reactData.sortData = sortList;
+              reactData.filterData = filterList;
+              reactData.tableLoading = true;
+              var applyArgs = [commitParams].concat(args);
+              return Promise.resolve((beforeQuery || ajaxMethods).apply(void 0, _toConsumableArray(applyArgs))).then(function (rest) {
+                var tableData = [];
+                reactData.tableLoading = false;
+                if (rest) {
+                  if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts)) {
+                    var totalProp = resConfigs.total;
+                    var total = (_xeUtils.default.isFunction(totalProp) ? totalProp({
+                      data: rest,
+                      $table: $xeTable,
+                      $grid: null,
+                      $gantt: $xeGantt
+                    }) : _xeUtils.default.get(rest, totalProp || 'page.total')) || 0;
+                    tablePage.total = _xeUtils.default.toNumber(total);
+                    var resultProp = resConfigs.result;
+                    tableData = (_xeUtils.default.isFunction(resultProp) ? resultProp({
+                      data: rest,
+                      $table: $xeTable,
+                      $grid: null,
+                      $gantt: $xeGantt
+                    }) : _xeUtils.default.get(rest, resultProp || 'result')) || [];
+                    // 检验当前页码，不能超出当前最大页数
+                    var pageCount = Math.max(Math.ceil(total / tablePage.pageSize), 1);
+                    if (tablePage.currentPage > pageCount) {
+                      tablePage.currentPage = pageCount;
+                    }
+                  } else {
+                    var listProp = resConfigs.list;
+                    tableData = (listProp ? _xeUtils.default.isFunction(listProp) ? listProp({
+                      data: rest,
+                      $table: $xeTable,
+                      $grid: null,
+                      $gantt: $xeGantt
+                    }) : _xeUtils.default.get(rest, listProp) : rest) || [];
+                  }
+                }
+                if ($xeTable) {
+                  $xeTable.loadData(tableData);
+                } else {
+                  $xeTable.$nextTick(function () {
+                    if ($xeTable) {
+                      $xeTable.loadData(tableData);
+                    }
+                  });
+                }
+                if (afterQuery) {
+                  afterQuery.apply(void 0, _toConsumableArray(applyArgs));
+                }
+                if (querySuccessMethods) {
+                  querySuccessMethods(Object.assign(Object.assign({}, commitParams), {
+                    response: rest
+                  }));
+                }
+                return {
+                  status: true
+                };
+              }).catch(function (rest) {
+                reactData.tableLoading = false;
+                if (queryErrorMethods) {
+                  queryErrorMethods(Object.assign(Object.assign({}, commitParams), {
+                    response: rest
+                  }));
+                }
+                return {
+                  status: false
+                };
+              });
+            } else {
+              (0, _log.errLog)('vxe.error.notFunc', ['proxy-config.ajax.query']);
+            }
+            break;
+          }
+        case 'delete':
+          {
+            var _ajaxMethods = ajax.delete;
+            var deleteSuccessMethods = ajax.deleteSuccess;
+            var deleteErrorMethods = ajax.deleteError;
+            if (_ajaxMethods) {
+              var selectRecords = $xeTable.getCheckboxRecords();
+              var removeRecords = selectRecords.filter(function (row) {
+                return !$xeTable.isInsertByRow(row);
+              });
+              var body = {
+                removeRecords: removeRecords
+              };
+              var _commitParams = {
+                $table: $xeTable,
+                $grid: null,
+                $gantt: $xeGantt,
+                code: code,
+                button: button,
+                body: body,
+                form: formData,
+                options: _ajaxMethods
+              };
+              var _applyArgs = [_commitParams].concat(args);
+              if (selectRecords.length) {
+                return $xeGantt.handleDeleteRow(code, 'vxe.grid.deleteSelectRecord', function () {
+                  if (!removeRecords.length) {
+                    return $xeTable.remove(selectRecords);
+                  }
+                  reactData.tableLoading = true;
+                  return Promise.resolve((beforeDelete || _ajaxMethods).apply(void 0, _toConsumableArray(_applyArgs))).then(function (rest) {
+                    reactData.tableLoading = false;
+                    $xeTable.setPendingRow(removeRecords, false);
+                    if (isRespMsg) {
+                      // 检测弹窗模块
+                      if (!_core.VxeUI.modal) {
+                        (0, _log.errLog)('vxe.error.reqModule', ['Modal']);
+                      }
+                      _core.VxeUI.modal.message({
+                        content: $xeGantt.getRespMsg(rest, 'vxe.grid.delSuccess'),
+                        status: 'success'
+                      });
+                    }
+                    if (afterDelete) {
+                      afterDelete.apply(void 0, _toConsumableArray(_applyArgs));
+                    } else {
+                      $xeGantt.commitProxy('query');
+                    }
+                    if (deleteSuccessMethods) {
+                      deleteSuccessMethods(Object.assign(Object.assign({}, _commitParams), {
+                        response: rest
+                      }));
+                    }
+                    return {
+                      status: true
+                    };
+                  }).catch(function (rest) {
+                    reactData.tableLoading = false;
+                    if (isRespMsg) {
+                      // 检测弹窗模块
+                      if (!_core.VxeUI.modal) {
+                        (0, _log.errLog)('vxe.error.reqModule', ['Modal']);
+                      }
+                      _core.VxeUI.modal.message({
+                        id: code,
+                        content: $xeGantt.getRespMsg(rest, 'vxe.grid.operError'),
+                        status: 'error'
+                      });
+                    }
+                    if (deleteErrorMethods) {
+                      deleteErrorMethods(Object.assign(Object.assign({}, _commitParams), {
+                        response: rest
+                      }));
+                    }
+                    return {
+                      status: false
+                    };
+                  });
+                });
+              } else {
+                if (isActiveMsg) {
+                  // 检测弹窗模块
+                  if (!_core.VxeUI.modal) {
+                    (0, _log.errLog)('vxe.error.reqModule', ['Modal']);
+                  }
+                  _core.VxeUI.modal.message({
+                    id: code,
+                    content: getI18n('vxe.grid.selectOneRecord'),
+                    status: 'warning'
+                  });
+                }
+              }
+            } else {
+              (0, _log.errLog)('vxe.error.notFunc', ['proxy-config.ajax.delete']);
+            }
+            break;
+          }
+        case 'save':
+          {
+            var _ajaxMethods2 = ajax.save;
+            var saveSuccessMethods = ajax.saveSuccess;
+            var saveErrorMethods = ajax.saveError;
+            if (_ajaxMethods2) {
+              var _body = $xeGantt.getRecordset();
+              var insertRecords = _body.insertRecords,
+                _removeRecords = _body.removeRecords,
+                updateRecords = _body.updateRecords,
+                pendingRecords = _body.pendingRecords;
+              var _commitParams2 = {
+                $table: $xeTable,
+                $grid: null,
+                $gantt: $xeGantt,
+                code: code,
+                button: button,
+                body: _body,
+                form: formData,
+                options: _ajaxMethods2
+              };
+              var _applyArgs2 = [_commitParams2].concat(args);
+              // 排除掉新增且标记为删除的数据
+              if (insertRecords.length) {
+                _body.pendingRecords = pendingRecords.filter(function (row) {
+                  return insertRecords.indexOf(row) === -1;
+                });
+              }
+              // 排除已标记为删除的数据
+              if (pendingRecords.length) {
+                _body.insertRecords = insertRecords.filter(function (row) {
+                  return pendingRecords.indexOf(row) === -1;
+                });
+              }
+              var restPromise = Promise.resolve();
+              if (editRules) {
+                // 只校验新增和修改的数据
+                restPromise = $xeGantt[validConfig && validConfig.msgMode === 'full' ? 'fullValidate' : 'validate'](_body.insertRecords.concat(updateRecords));
+              }
+              return restPromise.then(function (errMap) {
+                if (errMap) {
+                  // 如果校验不通过
+                  return;
+                }
+                if (_body.insertRecords.length || _removeRecords.length || updateRecords.length || _body.pendingRecords.length) {
+                  reactData.tableLoading = true;
+                  return Promise.resolve((beforeSave || _ajaxMethods2).apply(void 0, _toConsumableArray(_applyArgs2))).then(function (rest) {
+                    reactData.tableLoading = false;
+                    $xeTable.clearPendingRow();
+                    if (isRespMsg) {
+                      // 检测弹窗模块
+                      if (!_core.VxeUI.modal) {
+                        (0, _log.errLog)('vxe.error.reqModule', ['Modal']);
+                      }
+                      _core.VxeUI.modal.message({
+                        content: $xeGantt.getRespMsg(rest, 'vxe.grid.saveSuccess'),
+                        status: 'success'
+                      });
+                    }
+                    if (afterSave) {
+                      afterSave.apply(void 0, _toConsumableArray(_applyArgs2));
+                    } else {
+                      $xeGantt.commitProxy('query');
+                    }
+                    if (saveSuccessMethods) {
+                      saveSuccessMethods(Object.assign(Object.assign({}, _commitParams2), {
+                        response: rest
+                      }));
+                    }
+                    return {
+                      status: true
+                    };
+                  }).catch(function (rest) {
+                    reactData.tableLoading = false;
+                    if (isRespMsg) {
+                      // 检测弹窗模块
+                      if (!_core.VxeUI.modal) {
+                        (0, _log.errLog)('vxe.error.reqModule', ['Modal']);
+                      }
+                      _core.VxeUI.modal.message({
+                        id: code,
+                        content: $xeGantt.getRespMsg(rest, 'vxe.grid.operError'),
+                        status: 'error'
+                      });
+                    }
+                    if (saveErrorMethods) {
+                      saveErrorMethods(Object.assign(Object.assign({}, _commitParams2), {
+                        response: rest
+                      }));
+                    }
+                    return {
+                      status: false
+                    };
+                  });
+                } else {
+                  if (isActiveMsg) {
+                    // 检测弹窗模块
+                    if (!_core.VxeUI.modal) {
+                      (0, _log.errLog)('vxe.error.reqModule', ['Modal']);
+                    }
+                    _core.VxeUI.modal.message({
+                      id: code,
+                      content: getI18n('vxe.grid.dataUnchanged'),
+                      status: 'info'
+                    });
+                  }
+                }
+              });
+            } else {
+              (0, _log.errLog)('vxe.error.notFunc', ['proxy-config.ajax.save']);
+            }
+            break;
+          }
+        default:
+          {
+            var gCommandOpts = commands.get(code);
+            if (gCommandOpts) {
+              var tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod;
+              if (tCommandMethod) {
+                tCommandMethod.apply(void 0, [{
+                  code: code,
+                  button: button,
+                  $grid: null,
+                  $table: $xeTable,
+                  $gantt: $xeGantt
+                }].concat(args));
+              } else {
+                (0, _log.errLog)('vxe.error.notCommands', [code]);
+              }
+            }
+          }
+      }
+      return $xeGantt.$nextTick();
+    },
+    getParams: function getParams() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      return props.params;
+    },
+    zoom: function zoom() {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      if (reactData.isZMax) {
+        return $xeGantt.revert();
+      }
+      return $xeGantt.maximize();
+    },
+    isMaximized: function isMaximized() {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      return reactData.isZMax;
+    },
+    maximize: function maximize() {
+      var $xeGantt = this;
+      return $xeGantt.handleZoom(true);
+    },
+    revert: function revert() {
+      var $xeGantt = this;
+      return $xeGantt.handleZoom();
+    },
+    getFormData: function getFormData() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var proxyConfig = props.proxyConfig;
+      var formData = reactData.formData;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      var formOpts = $xeGantt.computeFormOpts;
+      return proxyConfig && (0, _utils.isEnableConf)(proxyOpts) && proxyOpts.form ? formData : formOpts.data;
+    },
+    getFormItems: function getFormItems(itemIndex) {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var formOpts = $xeGantt.computeFormOpts;
+      var formConfig = props.formConfig;
+      var items = formOpts.items;
+      var itemList = [];
+      _xeUtils.default.eachTree(formConfig && (0, _utils.isEnableConf)(formOpts) && items ? items : [], function (item) {
+        itemList.push(item);
+      }, {
+        children: 'children'
+      });
+      return _xeUtils.default.isUndefined(itemIndex) ? itemList : itemList[itemIndex];
+    },
+    resetForm: function resetForm() {
+      var $xeGantt = this;
+      var $form = $xeGantt.$refs.refForm;
+      if ($form) {
+        return $form.reset();
+      }
+      return $xeGantt.$nextTick();
+    },
+    validateForm: function validateForm() {
+      var $xeGantt = this;
+      var $form = $xeGantt.$refs.refForm;
+      if ($form) {
+        return $form.validate();
+      }
+      return $xeGantt.$nextTick();
+    },
+    validateFormField: function validateFormField(field) {
+      var $xeGantt = this;
+      var $form = $xeGantt.$refs.refForm;
+      if ($form) {
+        return $form.validateField(field);
+      }
+      return $xeGantt.$nextTick();
+    },
+    clearFormValidate: function clearFormValidate(field) {
+      var $xeGantt = this;
+      var $form = $xeGantt.$refs.refForm;
+      if ($form) {
+        return $form.clearValidate(field);
+      }
+      return $xeGantt.$nextTick();
+    },
+    homePage: function homePage() {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      var tablePage = reactData.tablePage;
+      tablePage.currentPage = 1;
+      return $xeGantt.$nextTick();
+    },
+    homePageByEvent: function homePageByEvent(evnt) {
+      var $xeGantt = this;
+      var $pager = $xeGantt.$refs.refPager;
+      if ($pager) {
+        $pager.homePageByEvent(evnt);
+      }
+    },
+    endPage: function endPage() {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      var tablePage = reactData.tablePage;
+      var pageCount = $xeGantt.computePageCount;
+      tablePage.currentPage = pageCount;
+      return $xeGantt.$nextTick();
+    },
+    endPageByEvent: function endPageByEvent(evnt) {
+      var $xeGantt = this;
+      var $pager = $xeGantt.$refs.refPager;
+      if ($pager) {
+        $pager.endPageByEvent(evnt);
+      }
+    },
+    setCurrentPage: function setCurrentPage(currentPage) {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      var tablePage = reactData.tablePage;
+      var pageCount = $xeGantt.computePageCount;
+      tablePage.currentPage = Math.min(pageCount, Math.max(1, _xeUtils.default.toNumber(currentPage)));
+      return $xeGantt.$nextTick();
+    },
+    setCurrentPageByEvent: function setCurrentPageByEvent(evnt, currentPage) {
+      var $xeGantt = this;
+      var $pager = $xeGantt.$refs.refPager;
+      if ($pager) {
+        $pager.setCurrentPageByEvent(evnt, currentPage);
+      }
+    },
+    setPageSize: function setPageSize(pageSize) {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      var tablePage = reactData.tablePage;
+      tablePage.pageSize = Math.max(1, _xeUtils.default.toNumber(pageSize));
+      return $xeGantt.$nextTick();
+    },
+    setPageSizeByEvent: function setPageSizeByEvent(evnt, pageSize) {
+      var $xeGantt = this;
+      var $pager = $xeGantt.$refs.refPager;
+      if ($pager) {
+        $pager.setPageSizeByEvent(evnt, pageSize);
+      }
+    },
+    getProxyInfo: function getProxyInfo() {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var $xeTable = $xeGantt.$refs.refTable;
+      var reactData = $xeGantt.reactData;
+      if (props.proxyConfig) {
+        var sortData = reactData.sortData;
+        return {
+          data: $xeTable ? $xeTable.getFullData() : [],
+          filter: reactData.filterData,
+          form: $xeGantt.getFormData(),
+          sort: sortData.length ? sortData[0] : {},
+          sorts: sortData,
+          pager: reactData.tablePage,
+          pendingRecords: $xeTable ? $xeTable.getPendingRecords() : []
+        };
+      }
+      return null;
+    },
+    refreshTaskView: function refreshTaskView() {
+      var $xeGantt = this;
+      var $ganttView = $xeGantt.$refs.refGanttView;
+      if ($ganttView) {
+        return $ganttView.refreshData();
+      }
+      return $xeGantt.$nextTick();
+    },
+    callSlot: function callSlot(slotFunc, params, h, vNodes) {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      if (slotFunc) {
+        if (_xeUtils.default.isString(slotFunc)) {
+          slotFunc = slots[slotFunc] || null;
+        }
+        if (_xeUtils.default.isFunction(slotFunc)) {
+          return getSlotVNs(slotFunc.call(this, params, h, vNodes));
+        }
+      }
+      return [];
+    },
+    /**
+     * 获取需要排除的高度
+     */
+    getExcludeHeight: function getExcludeHeight() {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      var isZMax = reactData.isZMax;
+      var el = $xeGantt.$refs.refElem;
+      if (el) {
+        var formWrapper = $xeGantt.$refs.refFormWrapper;
+        var toolbarWrapper = $xeGantt.$refs.refToolbarWrapper;
+        var topWrapper = $xeGantt.$refs.refTopWrapper;
+        var bottomWrapper = $xeGantt.$refs.refBottomWrapper;
+        var pagerWrapper = $xeGantt.$refs.refPagerWrapper;
+        var parentEl = el.parentElement;
+        var parentPaddingSize = isZMax ? 0 : parentEl ? (0, _dom.getPaddingTopBottomSize)(parentEl) : 0;
+        return parentPaddingSize + (0, _dom.getPaddingTopBottomSize)(el) + (0, _dom.getOffsetHeight)(formWrapper) + (0, _dom.getOffsetHeight)(toolbarWrapper) + (0, _dom.getOffsetHeight)(topWrapper) + (0, _dom.getOffsetHeight)(bottomWrapper) + (0, _dom.getOffsetHeight)(pagerWrapper);
+      }
+      return 0;
+    },
+    getParentHeight: function getParentHeight() {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      var el = $xeGantt.$refs.refElem;
+      if (el) {
+        var parentEl = el.parentElement;
+        return (reactData.isZMax ? (0, _dom.getDomNode)().visibleHeight : parentEl ? _xeUtils.default.toNumber(getComputedStyle(parentEl).height) : 0) - $xeGantt.getExcludeHeight();
+      }
+      return 0;
+    },
+    triggerToolbarCommitEvent: function triggerToolbarCommitEvent(params, evnt) {
+      var $xeGantt = this;
+      var code = params.code;
+      return $xeGantt.commitProxy(params, evnt).then(function (rest) {
+        if (code && rest && rest.status && ['query', 'reload', 'delete', 'save'].includes(code)) {
+          $xeGantt.dispatchEvent(code === 'delete' || code === 'save' ? "proxy-".concat(code) : 'proxy-query', Object.assign(Object.assign({}, rest), {
+            isReload: code === 'reload'
+          }), evnt);
+        }
+      });
+    },
+    triggerToolbarBtnEvent: function triggerToolbarBtnEvent(button, evnt) {
+      var $xeGantt = this;
+      $xeGantt.triggerToolbarCommitEvent(button, evnt);
+      $xeGantt.dispatchEvent('toolbar-button-click', {
+        code: button.code,
+        button: button
+      }, evnt);
+    },
+    triggerToolbarTolEvent: function triggerToolbarTolEvent(tool, evnt) {
+      var $xeGantt = this;
+      $xeGantt.triggerToolbarCommitEvent(tool, evnt);
+      $xeGantt.dispatchEvent('toolbar-tool-click', {
+        code: tool.code,
+        tool: tool
+      }, evnt);
+    },
+    triggerZoomEvent: function triggerZoomEvent(evnt) {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      $xeGantt.zoom();
+      $xeGantt.dispatchEvent('zoom', {
+        type: reactData.isZMax ? 'max' : 'revert'
+      }, evnt);
+    },
+    handleTaskCellClickEvent: function handleTaskCellClickEvent(evnt, params) {
+      var $xeGantt = this;
+      $xeGantt.dispatchEvent('task-cell-click', params, evnt);
+    },
+    handleTaskCellDblclickEvent: function handleTaskCellDblclickEvent(evnt, params) {
+      var $xeGantt = this;
+      $xeGantt.dispatchEvent('task-cell-dblclick', params, evnt);
+    },
+    handleTaskBarClickEvent: function handleTaskBarClickEvent(evnt, params) {
+      var $xeGantt = this;
+      $xeGantt.dispatchEvent('task-bar-click', params, evnt);
+    },
+    handleTaskBarDblclickEvent: function handleTaskBarDblclickEvent(evnt, params) {
+      var $xeGantt = this;
+      $xeGantt.dispatchEvent('task-bar-dblclick', params, evnt);
+    },
+    loadColumn: function loadColumn(columns) {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      var $xeTable = $xeGantt.$refs.refTable;
+      _xeUtils.default.eachTree(columns, function (column) {
+        if (column.slots) {
+          _xeUtils.default.each(column.slots, function (func) {
+            if (!_xeUtils.default.isFunction(func)) {
+              if (!slots[func]) {
+                (0, _log.errLog)('vxe.error.notSlot', [func]);
+              }
+            }
+          });
+        }
+      });
+      return $xeTable.loadColumn(columns);
+    },
+    reloadColumn: function reloadColumn(columns) {
+      var $xeGantt = this;
+      $xeGantt.clearAll();
+      return $xeGantt.loadColumn(columns);
+    },
+    getConfigSlot: function getConfigSlot(slotConfigs) {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      var slotConf = {};
+      _xeUtils.default.objectMap(slotConfigs, function (slotFunc, slotKey) {
+        if (slotFunc) {
+          if (_xeUtils.default.isString(slotFunc)) {
+            if (slots[slotFunc]) {
+              slotConf[slotKey] = slots[slotFunc];
+            } else {
+              (0, _log.errLog)('vxe.error.notSlot', [slotFunc]);
+            }
+          } else {
+            slotConf[slotKey] = slotFunc;
+          }
+        }
+      });
+      return slotConf;
+    },
+    getToolbarSlots: function getToolbarSlots() {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      var toolbarOpts = $xeGantt.computeToolbarOpts;
+      var toolbarOptSlots = toolbarOpts.slots;
+      var toolbarSlots = {};
+      if (slots.buttons && (!toolbarOptSlots || toolbarOptSlots.buttons !== 'buttons')) {
+        (0, _log.warnLog)('vxe.error.reqProp', ['toolbar-config.slots.buttons']);
+      }
+      if (slots.tools && (!toolbarOptSlots || toolbarOptSlots.tools !== 'tools')) {
+        (0, _log.warnLog)('vxe.error.reqProp', ['toolbar-config.slots.tools']);
+      }
+      if (toolbarOptSlots) {
+        var buttonsSlot = $xeGantt.getFuncSlot(toolbarOptSlots, 'buttons');
+        var buttonPrefixSlot = $xeGantt.getFuncSlot(toolbarOptSlots, 'buttonPrefix');
+        var buttonSuffixSlot = $xeGantt.getFuncSlot(toolbarOptSlots, 'buttonSuffix');
+        var toolsSlot = $xeGantt.getFuncSlot(toolbarOptSlots, 'tools');
+        var toolPrefixSlot = $xeGantt.getFuncSlot(toolbarOptSlots, 'toolPrefix');
+        var toolSuffixSlot = $xeGantt.getFuncSlot(toolbarOptSlots, 'toolSuffix');
+        if (buttonsSlot) {
+          toolbarSlots.buttons = buttonsSlot;
+        }
+        if (buttonPrefixSlot) {
+          toolbarSlots.buttonPrefix = buttonPrefixSlot;
+        }
+        if (buttonSuffixSlot) {
+          toolbarSlots.buttonSuffix = buttonSuffixSlot;
+        }
+        if (toolsSlot) {
+          toolbarSlots.tools = toolsSlot;
+        }
+        if (toolPrefixSlot) {
+          toolbarSlots.toolPrefix = toolPrefixSlot;
+        }
+        if (toolSuffixSlot) {
+          toolbarSlots.toolSuffix = toolSuffixSlot;
+        }
+      }
+      return toolbarSlots;
+    },
+    getFuncSlot: function getFuncSlot(optSlots, slotKey) {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      var funcSlot = optSlots[slotKey];
+      if (funcSlot) {
+        if (_xeUtils.default.isString(funcSlot)) {
+          if (slots[funcSlot]) {
+            return slots[funcSlot];
+          } else {
+            (0, _log.errLog)('vxe.error.notSlot', [funcSlot]);
+          }
+        } else {
+          return funcSlot;
+        }
+      }
+      return null;
+    },
+    //
+    // Render
+    //
+    renderDefaultForm: function renderDefaultForm(h) {
+      var VxeUIFormComponent = _core.VxeUI.getComponent('VxeForm');
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var slots = $xeGantt.$scopedSlots;
+      var reactData = $xeGantt.reactData;
+      var proxyConfig = props.proxyConfig,
+        formConfig = props.formConfig;
+      var formData = reactData.formData;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      var formOpts = $xeGantt.computeFormOpts;
+      if ((0, _utils.isEnableConf)(formConfig) && formOpts.items && formOpts.items.length) {
+        var formSlots = {};
+        if (!formOpts.inited) {
+          formOpts.inited = true;
+          var beforeItem = proxyOpts.beforeItem;
+          if (proxyOpts && beforeItem) {
+            formOpts.items.forEach(function (item) {
+              beforeItem.call($xeGantt, {
+                $grid: $xeGantt,
+                $gantt: null,
+                item: item
+              });
+            });
+          }
+        }
+        // 处理插槽
+        formOpts.items.forEach(function (item) {
+          _xeUtils.default.each(item.slots, function (func) {
+            if (!_xeUtils.default.isFunction(func)) {
+              if (slots[func]) {
+                formSlots[func] = slots[func];
+              }
+            }
+          });
+        });
+        return [VxeUIFormComponent ? h(VxeUIFormComponent, {
+          props: Object.assign({}, formOpts, {
+            data: proxyConfig && proxyOpts.form ? formData : formOpts.data
+          }),
+          on: {
+            submit: $xeGantt.submitFormEvent,
+            reset: $xeGantt.resetFormEvent,
+            collapse: $xeGantt.collapseEvent,
+            'submit-invalid': $xeGantt.submitInvalidEvent
+          },
+          scopedSlots: formSlots
+        }) : renderEmptyElement($xeGantt)];
+      }
+      return [];
+    },
+    renderForm: function renderForm(h) {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var slots = $xeGantt.$scopedSlots;
+      var formConfig = props.formConfig;
+      var formSlot = slots.form;
+      var hasForm = !!(formSlot || (0, _utils.isEnableConf)(formConfig));
+      if (hasForm) {
+        return h('div', {
+          key: 'form',
+          ref: 'refFormWrapper',
+          class: 'vxe-gantt--form-wrapper'
+        }, formSlot ? formSlot.call($xeGantt, {
+          $grid: null,
+          $gantt: $xeGantt
+        }) : $xeGantt.renderDefaultForm(h));
+      }
+      return renderEmptyElement($xeGantt);
+    },
+    renderToolbar: function renderToolbar(h) {
+      var VxeUIToolbarComponent = _core.VxeUI.getComponent('VxeToolbar');
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var slots = $xeGantt.$scopedSlots;
+      var toolbarConfig = props.toolbarConfig;
+      var toolbarSlot = slots.toolbar;
+      var hasToolbar = !!(toolbarSlot || (0, _utils.isEnableConf)(toolbarConfig) || toolbar);
+      var toolbarOpts = $xeGantt.computeToolbarOpts;
+      if (hasToolbar) {
+        return h('div', {
+          key: 'toolbar',
+          ref: 'refToolbarWrapper',
+          class: 'vxe-gantt--toolbar-wrapper'
+        }, toolbarSlot ? toolbarSlot.call($xeGantt, {
+          $grid: null,
+          $gantt: $xeGantt
+        }) : [h(VxeUIToolbarComponent, {
+          props: Object.assign({}, toolbarOpts, {
+            slots: undefined
+          }),
+          ref: 'refToolbar',
+          scopedSlots: $xeGantt.getToolbarSlots()
+        })]);
+      }
+      return renderEmptyElement($xeGantt);
+    },
+    renderTop: function renderTop(h) {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      var topSlot = slots.top;
+      return topSlot ? h('div', {
+        key: 'top',
+        ref: 'refTopWrapper',
+        class: 'vxe-gantt--top-wrapper'
+      }, topSlot.call($xeGantt, {
+        $grid: null,
+        $gantt: $xeGantt
+      })) : renderEmptyElement($xeGantt);
+    },
+    renderTableLeft: function renderTableLeft(h) {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      var leftSlot = slots.left;
+      if (leftSlot) {
+        return h('div', {
+          class: 'vxe-gantt--left-wrapper'
+        }, leftSlot({
+          $grid: null,
+          $gantt: $xeGantt
+        }));
+      }
+      return renderEmptyElement($xeGantt);
+    },
+    renderTableRight: function renderTableRight(h) {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      var rightSlot = slots.right;
+      if (rightSlot) {
+        return h('div', {
+          class: 'vxe-gantt--right-wrapper'
+        }, rightSlot({
+          $grid: null,
+          $gantt: $xeGantt
+        }));
+      }
+      return renderEmptyElement($xeGantt);
+    },
+    renderTable: function renderTable(h) {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      var tableProps = $xeGantt.computeTableProps;
+      return h('div', {
+        class: 'vxe-gantt--table-wrapper'
+      }, [h(_vxeTable.VxeTable, {
+        key: 'table',
+        props: tableProps,
+        on: getTableOns($xeGantt),
+        scopedSlots: slots,
+        ref: 'refTable'
+      })]);
+    },
+    renderBottom: function renderBottom(h) {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      var bottomSlot = slots.bottom;
+      return bottomSlot ? h('div', {
+        key: 'bottom',
+        ref: 'refBottomWrapper',
+        class: 'vxe-gantt--bottom-wrapper'
+      }, bottomSlot.call($xeGantt, {
+        $grid: null,
+        $gantt: $xeGantt
+      })) : renderEmptyElement($xeGantt);
+    },
+    renderPager: function renderPager(h) {
+      var VxeUIPagerComponent = _core.VxeUI.getComponent('VxePager');
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var slots = $xeGantt.$scopedSlots;
+      var reactData = $xeGantt.reactData;
+      var proxyConfig = props.proxyConfig,
+        pagerConfig = props.pagerConfig;
+      var proxyOpts = $xeGantt.computeProxyOpts;
+      var pagerOpts = $xeGantt.computePagerOpts;
+      var pagerSlot = slots.pager;
+      if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts) || slots.pager) {
+        return h('div', {
+          ref: 'refPagerWrapper',
+          key: 'pager',
+          class: 'vxe-gantt--pager-wrapper'
+        }, pagerSlot ? pagerSlot.call($xeGantt, {
+          $grid: null,
+          $gantt: $xeGantt
+        }) : [VxeUIPagerComponent ? h(VxeUIPagerComponent, {
+          ref: 'refPager',
+          props: Object.assign(Object.assign({}, pagerOpts), proxyConfig && (0, _utils.isEnableConf)(proxyOpts) ? reactData.tablePage : {}),
+          on: {
+            'page-change': $xeGantt.pageChangeEvent
+          },
+          scopedSlots: $xeGantt.getConfigSlot(pagerOpts.slots)
+        }) : renderEmptyElement($xeGantt)]);
+      }
+      return renderEmptyElement($xeGantt);
+    },
+    /**
+     * 渲染任务视图
+     */
+    renderTaskView: function renderTaskView(h) {
+      return h('div', {
+        ref: 'refGanttWrapper',
+        class: 'vxe-gantt--view-wrapper'
+      }, [h(_ganttView.default, {
+        ref: 'refGanttView'
+      })]);
+    },
+    renderSplitBar: function renderSplitBar(h) {
+      var $xeGantt = this;
+      var reactData = $xeGantt.reactData;
+      var showLeftView = reactData.showLeftView,
+        showRightView = reactData.showRightView;
+      var taskSplitOpts = $xeGantt.computeTaskSplitOpts;
+      var enabled = taskSplitOpts.enabled,
+        resize = taskSplitOpts.resize,
+        showCollapseTableButton = taskSplitOpts.showCollapseTableButton,
+        showCollapseTaskButton = taskSplitOpts.showCollapseTaskButton;
+      if (!enabled) {
+        return renderEmptyElement($xeGantt);
+      }
+      var ons = {};
+      if (resize) {
+        ons.mousedown = $xeGantt.dragSplitEvent;
+      }
+      return h('div', {
+        class: ['vxe-gantt--view-split-bar', {
+          'is--resize': resize,
+          on: ons
+        }]
+      }, [h('div', {
+        class: 'vxe-gantt--view-split-bar-handle'
+      }), showCollapseTableButton || showCollapseTaskButton ? h('div', {
+        class: 'vxe-gantt--view-split-bar-btn-wrapper'
+      }, [showCollapseTableButton && showRightView ? h('div', {
+        class: 'vxe-gantt--view-split-bar-left-btn',
+        on: {
+          click: $xeGantt.handleSplitLeftViewEvent
+        }
+      }, [h('i', {
+        class: showLeftView ? getIcon().GANTT_VIEW_LEFT_OPEN : getIcon().GANTT_VIEW_LEFT_CLOSE
+      })]) : renderEmptyElement($xeGantt), showCollapseTaskButton && showLeftView ? h('div', {
+        class: 'vxe-gantt--view-split-bar-right-btn',
+        on: {
+          click: $xeGantt.handleSplitRightViewEvent
+        }
+      }, [h('i', {
+        class: showRightView ? getIcon().GANTT_VIEW_RIGHT_OPEN : getIcon().GANTT_VIEW_RIGHT_CLOSE
+      })]) : renderEmptyElement($xeGantt)]) : renderEmptyElement($xeGantt)]);
+    },
+    renderChildLayout: function renderChildLayout(h, layoutKeys) {
+      var $xeGantt = this;
+      var childVNs = [];
+      layoutKeys.forEach(function (key) {
+        switch (key) {
+          case 'Form':
+            childVNs.push($xeGantt.renderForm(h));
+            break;
+          case 'Toolbar':
+            childVNs.push($xeGantt.renderToolbar(h));
+            break;
+          case 'Top':
+            childVNs.push($xeGantt.renderTop(h));
+            break;
+          case 'Gantt':
+            childVNs.push(h('div', {
+              ref: 'refGanttContainer',
+              key: 'tv',
+              class: 'vxe-gantt--gantt-container'
+            }, [$xeGantt.renderTableLeft(h), $xeGantt.renderTable(h), $xeGantt.renderSplitBar(h), $xeGantt.renderTaskView(h), $xeGantt.renderTableRight(h), h('div', {
+              ref: 'refResizableSplitTip',
+              class: 'vxe-gantt--resizable-split-tip'
+            }, [h('div', {
+              class: 'vxe-gantt--resizable-split-tip-number'
+            }, [h('div', {
+              class: 'vxe-gantt--resizable-split-number-left'
+            }, '10px'), h('div', {
+              class: 'vxe-gantt--resizable-split-number-right'
+            }, '20px')])])]));
+            break;
+          case 'Bottom':
+            childVNs.push($xeGantt.renderBottom(h));
+            break;
+          case 'Pager':
+            childVNs.push($xeGantt.renderPager(h));
+            break;
+          default:
+            (0, _log.errLog)('vxe.error.notProp', ["layouts -> ".concat(key)]);
+            break;
+        }
+      });
+      return childVNs;
+    },
+    renderLayout: function renderLayout(h) {
+      var $xeGantt = this;
+      var slots = $xeGantt.$scopedSlots;
+      var currLayoutConf = $xeGantt.computeCurrLayoutConf;
+      var headKeys = currLayoutConf.headKeys,
+        bodyKeys = currLayoutConf.bodyKeys,
+        footKeys = currLayoutConf.footKeys;
+      var asideLeftSlot = slots.asideLeft || slots['aside-left'];
+      var asideRightSlot = slots.asideRight || slots['aside-right'];
+      return [h('div', {
+        class: 'vxe-gantt--layout-header-wrapper'
+      }, $xeGantt.renderChildLayout(h, headKeys)), h('div', {
+        class: 'vxe-gantt--layout-body-wrapper'
+      }, [asideLeftSlot ? h('div', {
+        class: 'vxe-gantt--layout-aside-left-wrapper'
+      }, asideLeftSlot({})) : renderEmptyElement($xeGantt), h('div', {
+        class: 'vxe-gantt--layout-body-content-wrapper'
+      }, $xeGantt.renderChildLayout(h, bodyKeys)), asideRightSlot ? h('div', {
+        class: 'vxe-gantt--layout-aside-right-wrapper'
+      }, asideRightSlot({})) : renderEmptyElement($xeGantt)]), h('div', {
+        class: 'vxe-gantt--layout-footer-wrapper'
+      }, $xeGantt.renderChildLayout(h, footKeys)), h('div', {
+        class: 'vxe-gantt--border-line'
+      })];
+    },
+    renderVN: function renderVN(h) {
+      var $xeGantt = this;
+      var props = $xeGantt;
+      var reactData = $xeGantt.reactData;
+      var showLeftView = reactData.showLeftView,
+        showRightView = reactData.showRightView;
+      var vSize = $xeGantt.computeSize;
+      var styles = $xeGantt.computeStyles;
+      var isLoading = $xeGantt.computeIsLoading;
+      var tableBorder = $xeGantt.computeTableBorder;
+      var scrollbarXToTop = $xeGantt.computeScrollbarXToTop;
+      var scrollbarYToLeft = $xeGantt.computeScrollbarYToLeft;
+      return h('div', {
+        ref: 'refElem',
+        class: ['vxe-gantt', "border--".concat(tableBorder), "sx-pos--".concat(scrollbarXToTop ? 'top' : 'bottom'), "sy-pos--".concat(scrollbarYToLeft ? 'left' : 'right'), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, "size--".concat(vSize), vSize), 'is--round', props.round), 'is--maximize', reactData.isZMax), 'is--loading', isLoading), 'show--left', showLeftView), 'show--right', showRightView)],
+        style: styles
+      }, $xeGantt.renderLayout(h));
+    }
+  }),
+  created: function created() {
+    // 使用已安装的组件，如果未安装则不渲染
+    var VxeUIFormComponent = _core.VxeUI.getComponent('VxeForm');
+    var VxeUIPagerComponent = _core.VxeUI.getComponent('VxePager');
+    var VxeUIToolbarComponent = _core.VxeUI.getComponent('VxeToolbar');
+    var $xeGantt = this;
+    var props = $xeGantt;
+    var proxyOpts = $xeGantt.computeProxyOpts;
+    if (props.toolbar) {
+      (0, _log.errLog)('vxe.error.delProp', ['grid.toolbar', 'grid.toolbar-config']);
+    }
+    if (props.toolbarConfig && !_xeUtils.default.isObject(props.toolbarConfig)) {
+      (0, _log.errLog)('vxe.error.errProp', ["grid.toolbar-config=".concat(props.toolbarConfig), 'grid.toolbar-config={}']);
+    }
+    if (proxyOpts.props) {
+      (0, _log.warnLog)('vxe.error.delProp', ['proxy-config.props', 'proxy-config.response']);
+    }
+    $xeGantt.$nextTick(function () {
+      if (props.formConfig) {
+        if (!VxeUIFormComponent) {
+          (0, _log.errLog)('vxe.error.reqComp', ['vxe-form']);
+        }
+      }
+      if (props.pagerConfig) {
+        if (!VxeUIPagerComponent) {
+          (0, _log.errLog)('vxe.error.reqComp', ['vxe-pager']);
+        }
+      }
+      if (props.toolbarConfig) {
+        if (!VxeUIToolbarComponent) {
+          (0, _log.errLog)('vxe.error.reqComp', ['vxe-toolbar']);
+        }
+      }
     });
-    $xeGantt.renderVN = renderVN;
-    return $xeGantt;
+    $xeGantt.initPages();
   },
-  render() {
-    return this.renderVN();
+  mounted: function mounted() {
+    var $xeGantt = this;
+    var props = $xeGantt;
+    var columns = props.columns;
+    if (columns && columns.length) {
+      $xeGantt.loadColumn(columns);
+    }
+    $xeGantt.initToolbar();
+    $xeGantt.initProxy();
+    $xeGantt.initGanttView();
+    globalEvents.on($xeGantt, 'keydown', $xeGantt.handleGlobalKeydownEvent);
+  },
+  destroyed: function destroyed() {
+    var $xeGantt = this;
+    var internalData = $xeGantt.internalData;
+    globalEvents.off($xeGantt, 'keydown');
+    _xeUtils.default.assign(internalData, createInternalData());
+  },
+  render: function render(h) {
+    return this.renderVN(h);
   }
-});
+});
+/* define-vxe-component end */