"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _comp = require("../../ui/src/comp");
var _xeUtils = _interopRequireDefault(require("xe-utils"));
var _utils = require("../../ui/src/utils");
var _dom = require("../../ui/src/dom");
var _ui = require("../../ui");
var _vn = require("../../ui/src/vn");
var _log = require("../../ui/src/log");
var _props = require("../../table/src/props");
var _table = _interopRequireDefault(require("../../table/src/table"));
var _toolbar = _interopRequireDefault(require("../../toolbar/src/toolbar"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const {
  getConfig,
  getI18n,
  commands,
  globalEvents,
  globalMixins,
  createEvent,
  GLOBAL_EVENT_KEYS,
  renderEmptyElement
} = _ui.VxeUI;
const tableMethods = {};
const propKeys = Object.keys(_props.tableProps);
const defaultLayouts = [['Form'], ['Toolbar', 'Top', 'Table', 'Bottom', 'Pager']];
function getTableOns(_vm) {
  const {
    $listeners,
    proxyConfig,
    proxyOpts
  } = _vm;
  const ons = {};
  _xeUtils.default.each($listeners, (cb, type) => {
    ons[type] = (...args) => {
      _vm.$emit(type, ...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(_table.default.methods, (fn, name) => {
  tableMethods[name] = function (...args) {
    const $xeGrid = this;
    const $xeTable = $xeGrid.$refs.refTable;
    return $xeTable && $xeTable[name](...args);
  };
});
function createInternalData() {
  return {
    uFoot: false
  };
}
var _default = exports.default = /* define-vxe-component start */(0, _comp.defineVxeComponent)({
  name: 'VxeGrid',
  mixins: [globalMixins.sizeMixin],
  props: Object.assign(Object.assign({}, _props.tableProps), {
    layouts: Array,
    columns: Array,
    pagerConfig: Object,
    proxyConfig: Object,
    toolbarConfig: Object,
    formConfig: Object,
    zoomConfig: Object,
    size: {
      type: String,
      default: () => getConfig().grid.size || getConfig().size
    }
  }),
  provide() {
    const $xeGrid = this;
    const $xeGantt = null;
    return {
      $xeGrid,
      $xeGantt
    };
  },
  data() {
    var _a;
    const xID = _xeUtils.default.uniqueId();
    const reactData = {
      tableLoading: false,
      proxyInited: false,
      isZMax: false,
      tableData: [],
      filterData: [],
      formData: {},
      sortData: [],
      footerData: [],
      tZindex: 0,
      tablePage: {
        total: 0,
        pageSize: ((_a = getConfig().pager) === null || _a === void 0 ? void 0 : _a.pageSize) || 10,
        currentPage: 1
      }
    };
    const internalData = createInternalData();
    return {
      xID,
      reactData,
      internalData
    };
  },
  computed: Object.assign(Object.assign({}, {}), {
    isRespMsg() {
      const $xeGrid = this;
      return $xeGrid.computeIsRespMsg;
    },
    computeIsRespMsg() {
      const $xeGrid = this;
      const proxyOpts = $xeGrid.computeProxyOpts;
      return !!(_xeUtils.default.isBoolean(proxyOpts.message) ? proxyOpts.message : proxyOpts.showResponseMsg);
    },
    isActiveMsg() {
      const $xeGrid = this;
      return $xeGrid.computeIsActiveMsg;
    },
    computeIsActiveMsg() {
      const $xeGrid = this;
      const proxyOpts = $xeGrid.computeProxyOpts;
      return _xeUtils.default.isBoolean(proxyOpts.showActionMsg) ? proxyOpts.showActionMsg : !!proxyOpts.showActiveMsg;
    },
    proxyOpts() {
      const $xeGrid = this;
      return $xeGrid.computeProxyOpts;
    },
    computeProxyOpts() {
      const $xeGrid = this;
      const props = $xeGrid;
      return _xeUtils.default.merge({}, _xeUtils.default.clone(getConfig().grid.proxyConfig, true), props.proxyConfig);
    },
    pagerOpts() {
      const $xeGrid = this;
      return $xeGrid.computePagerOpts;
    },
    computePagerOpts() {
      const $xeGrid = this;
      const props = $xeGrid;
      return Object.assign({}, getConfig().grid.pagerConfig, props.pagerConfig);
    },
    formOpts() {
      const $xeGrid = this;
      return $xeGrid.computeFormOpts;
    },
    computeFormOpts() {
      const $xeGrid = this;
      const props = $xeGrid;
      return Object.assign({}, getConfig().grid.formConfig, props.formConfig);
    },
    toolbarOpts() {
      const $xeGrid = this;
      return $xeGrid.computeToolbarOpts;
    },
    computeToolbarOpts() {
      const $xeGrid = this;
      const props = $xeGrid;
      return Object.assign({}, getConfig().grid.toolbarConfig, props.toolbarConfig);
    },
    zoomOpts() {
      const $xeGrid = this;
      return $xeGrid.computeZoomOpts;
    },
    computeZoomOpts() {
      const $xeGrid = this;
      const props = $xeGrid;
      return Object.assign({}, getConfig().grid.zoomConfig, props.zoomConfig);
    },
    computeStyles() {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const {
        height,
        maxHeight
      } = props;
      const {
        isZMax,
        tZindex
      } = reactData;
      const 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);
        }
      }
      return stys;
    },
    computeTableExtendProps() {
      const $xeGrid = this;
      const props = $xeGrid;
      const rest = {};
      const gridProps = props;
      propKeys.forEach(key => {
        if (gridProps[key] !== undefined) {
          rest[key] = gridProps[key];
        }
      });
      return rest;
    },
    computeTableProps() {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const {
        showFooter,
        seqConfig,
        pagerConfig,
        editConfig,
        proxyConfig
      } = props;
      const {
        isZMax,
        tablePage,
        footerData
      } = reactData;
      const tableExtendProps = $xeGrid.computeTableExtendProps;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const pagerOpts = $xeGrid.computePagerOpts;
      const isLoading = $xeGrid.computeIsLoading;
      const tProps = Object.assign({}, tableExtendProps);
      if (showFooter && !tProps.footerData) {
        // 如果未设置自己的标位数据，则使用代理的
        tProps.footerData = footerData;
      } else if (proxyOpts.footer && footerData.length) {
        // 如果代理标为数据，且未请求到数据，则用自己的
        tProps.footerData = footerData;
      }
      if (isZMax) {
        if (tProps.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() {
      const $xeGrid = this;
      return $xeGrid.computeTableProps;
    },
    computeCurrLayoutConf() {
      const $xeGrid = this;
      const props = $xeGrid;
      const {
        layouts
      } = props;
      let confs = [];
      if (layouts && layouts.length) {
        confs = layouts;
      } else {
        confs = getConfig().grid.layouts || defaultLayouts;
      }
      let headKeys = [];
      let bodyKeys = [];
      let footKeys = [];
      if (confs.length) {
        if (_xeUtils.default.isArray(confs[0])) {
          headKeys = confs[0];
          bodyKeys = confs[1] || [];
          footKeys = confs[2] || [];
        } else {
          bodyKeys = confs;
        }
      }
      return {
        headKeys,
        bodyKeys,
        footKeys
      };
    },
    computeCustomCurrentPageFlag() {
      const $xeGrid = this;
      const pagerOpts = $xeGrid.computePagerOpts;
      return pagerOpts.currentPage;
    },
    computeCustomPageSizeFlag() {
      const $xeGrid = this;
      const pagerOpts = $xeGrid.computePagerOpts;
      return pagerOpts.pageSize;
    },
    computeCustomTotalFlag() {
      const $xeGrid = this;
      const pagerOpts = $xeGrid.computePagerOpts;
      return pagerOpts.total;
    },
    computePageCount() {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      const {
        tablePage
      } = reactData;
      return Math.max(Math.ceil(tablePage.total / tablePage.pageSize), 1);
    },
    computeIsLoading() {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const {
        loading,
        proxyConfig
      } = props;
      const {
        tableLoading
      } = reactData;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const {
        showLoading
      } = proxyOpts;
      return loading || tableLoading && showLoading && proxyConfig && (0, _utils.isEnableConf)(proxyOpts);
    }
  }),
  watch: {
    columns(value) {
      const $xeGrid = this;
      $xeGrid.$nextTick(() => $xeGrid.loadColumn(value));
    },
    toolbar(value) {
      const $xeGrid = this;
      if (value) {
        $xeGrid.initToolbar();
      }
    },
    toolbarConfig(value) {
      const $xeGrid = this;
      if (value) {
        $xeGrid.initToolbar();
      }
    },
    proxyConfig() {
      const $xeGrid = this;
      $xeGrid.initProxy();
    },
    computeCustomCurrentPageFlag() {
      const $xeGrid = this;
      $xeGrid.initPages('currentPage');
    },
    computeCustomPageSizeFlag() {
      const $xeGrid = this;
      $xeGrid.initPages('pageSize');
    },
    computeCustomTotalFlag() {
      const $xeGrid = this;
      $xeGrid.initPages('total');
    }
  },
  methods: Object.assign(Object.assign({}, tableMethods), {
    dispatchEvent(type, params, evnt) {
      const $xeGrid = this;
      $xeGrid.$emit(type, createEvent(evnt, {
        $grid: $xeGrid,
        $gantt: null
      }, params));
    },
    initPages(propKey) {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const {
        tablePage
      } = reactData;
      const {
        pagerConfig
      } = props;
      const pagerOpts = $xeGrid.computePagerOpts;
      if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts)) {
        if (propKey) {
          if (pagerOpts[propKey]) {
            tablePage[propKey] = _xeUtils.default.toNumber(pagerOpts[propKey]);
          }
        } else {
          const {
            currentPage,
            pageSize,
            total
          } = pagerOpts;
          if (currentPage) {
            tablePage.currentPage = currentPage;
          }
          if (pageSize) {
            tablePage.pageSize = pageSize;
          }
          if (total) {
            tablePage.total = total;
          }
        }
      }
    },
    callSlot(slotFunc, params, h) {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      if (slotFunc) {
        if (_xeUtils.default.isString(slotFunc)) {
          slotFunc = slots[slotFunc] || null;
        }
        if (_xeUtils.default.isFunction(slotFunc)) {
          return (0, _vn.getSlotVNs)(slotFunc.call(this, params, h));
        }
      }
      return [];
    },
    getEl() {
      const $xeGrid = this;
      return $xeGrid.$refs.refElem;
    },
    /**
     * 获取需要排除的高度
     */
    getExcludeHeight() {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const {
        height
      } = props;
      const {
        isZMax
      } = reactData;
      const el = $xeGrid.$refs.refElem;
      if (el) {
        const formWrapper = $xeGrid.$refs.refFormWrapper;
        const toolbarWrapper = $xeGrid.$refs.refToolbarWrapper;
        const topWrapper = $xeGrid.$refs.refTopWrapper;
        const bottomWrapper = $xeGrid.$refs.refBottomWrapper;
        const pagerWrapper = $xeGrid.$refs.refPagerWrapper;
        const parentEl = el.parentElement;
        let parentPaddingSize = 0;
        if (parentEl && (height === '100%' || height === 'auto')) {
          parentPaddingSize = isZMax ? 0 : (0, _dom.getPaddingTopBottomSize)(parentEl);
        }
        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() {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      const el = $xeGrid.$refs.refElem;
      if (el) {
        const parentEl = el.parentElement;
        return (reactData.isZMax ? (0, _dom.getDomNode)().visibleHeight : parentEl ? _xeUtils.default.toNumber(getComputedStyle(parentEl).height) : 0) - $xeGrid.getExcludeHeight();
      }
      return 0;
    },
    initToolbar() {
      const $xeGrid = this;
      $xeGrid.$nextTick(() => {
        const $xeTable = $xeGrid.$refs.refTable;
        const $xeToolbar = $xeGrid.$refs.refToolbar;
        if ($xeTable && $xeToolbar) {
          $xeTable.connectToolbar($xeToolbar);
        }
      });
    },
    getDefaultFormData() {
      const $xeGrid = this;
      const formOpts = $xeGrid.computeFormOpts;
      if (formOpts.items) {
        const fData = {};
        formOpts.items.forEach(item => {
          const {
            field,
            itemRender
          } = item;
          if (field) {
            let itemValue = null;
            if (itemRender) {
              const {
                startField,
                endField,
                defaultValue
              } = itemRender;
              if (_xeUtils.default.isFunction(defaultValue)) {
                itemValue = defaultValue({
                  item
                });
              } else if (!_xeUtils.default.isUndefined(defaultValue)) {
                itemValue = defaultValue;
              }
              if (startField && endField) {
                _xeUtils.default.set(fData, startField, null);
                _xeUtils.default.set(fData, endField, null);
              }
            }
            fData[field] = itemValue;
          }
        });
        return fData;
      }
      return {};
    },
    initProxy() {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const internalData = $xeGrid.internalData;
      const {
        proxyConfig,
        formConfig
      } = props;
      const {
        proxyInited
      } = reactData;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const formOpts = $xeGrid.computeFormOpts;
      if (proxyConfig) {
        if ((0, _utils.isEnableConf)(formConfig) && proxyOpts.form && formOpts.items) {
          reactData.formData = $xeGrid.getDefaultFormData();
        }
        if (!proxyInited) {
          reactData.proxyInited = true;
          if (proxyOpts.autoLoad !== false) {
            $xeGrid.$nextTick().then(() => {
              internalData.uFoot = true;
              const rest = $xeGrid.commitProxy('initial');
              internalData.uFoot = false;
              $xeGrid.updateQueryFooter();
              return rest;
            }).then(rest => {
              $xeGrid.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), {
                isInited: true
              }), new Event('initial'));
            });
          }
        }
      }
    },
    updateQueryFooter() {
      const $xeGrid = this;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const {
        ajax
      } = proxyOpts;
      if (ajax && ajax.queryFooter) {
        return $xeGrid.commitProxy('queryFooter');
      }
    },
    handleGlobalKeydownEvent(evnt) {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      const zoomOpts = $xeGrid.computeZoomOpts;
      const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
      if (isEsc && reactData.isZMax && zoomOpts.escRestore !== false) {
        $xeGrid.triggerZoomEvent(evnt);
      }
    },
    getRespMsg(rest, defaultMsg) {
      const $xeGrid = this;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const resConfigs = proxyOpts.response || proxyOpts.props || {};
      const messageProp = resConfigs.message;
      const $xeTable = $xeGrid.$refs.refTable;
      let msg;
      if (rest && messageProp) {
        msg = _xeUtils.default.isFunction(messageProp) ? messageProp({
          data: rest,
          $table: $xeTable,
          $grid: $xeGrid,
          $gantt: null
        }) : _xeUtils.default.get(rest, messageProp);
      }
      return msg || getI18n(defaultMsg);
    },
    handleDeleteRow(code, alertKey, callback) {
      const $xeGrid = this;
      const isActiveMsg = $xeGrid.computeIsActiveMsg;
      const selectRecords = $xeGrid.getCheckboxRecords();
      if (isActiveMsg) {
        if (selectRecords.length) {
          if (_ui.VxeUI.modal) {
            return _ui.VxeUI.modal.confirm({
              id: `cfm_${code}`,
              content: getI18n(alertKey),
              escClosable: true
            }).then(type => {
              if (type === 'confirm') {
                return callback();
              }
            });
          }
        } else {
          if (_ui.VxeUI.modal) {
            _ui.VxeUI.modal.message({
              id: `msg_${code}`,
              content: getI18n('vxe.grid.selectOneRecord'),
              status: 'warning'
            });
          }
        }
      } else {
        if (selectRecords.length) {
          callback();
        }
      }
      return Promise.resolve();
    },
    triggerPendingEvent(code) {
      const $xeGrid = this;
      const isActiveMsg = $xeGrid.computeIsActiveMsg;
      const $xeTable = $xeGrid.$refs.refTable;
      const selectRecords = $xeTable.getCheckboxRecords();
      if (selectRecords.length) {
        $xeTable.togglePendingRow(selectRecords);
        $xeGrid.clearCheckboxRow();
      } else {
        if (isActiveMsg) {
          if (_ui.VxeUI.modal) {
            _ui.VxeUI.modal.message({
              id: code,
              content: getI18n('vxe.grid.selectOneRecord'),
              status: 'warning'
            });
          }
        }
      }
    },
    /**
     * 提交指令，支持 code 或 button
     * @param {String/Object} code 字符串或对象
     */
    commitProxy(proxyTarget, ...args) {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const internalData = $xeGrid.internalData;
      /**
       * 已废弃
       * @deprecated
       */
      const toolbar = props.toolbar;
      const {
        showFooter,
        proxyConfig,
        toolbarConfig,
        pagerConfig,
        editRules,
        validConfig
      } = props;
      const {
        tablePage
      } = reactData;
      const isActiveMsg = $xeGrid.computeIsActiveMsg;
      const isRespMsg = $xeGrid.computeIsRespMsg;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const pagerOpts = $xeGrid.computePagerOpts;
      const toolbarOpts = $xeGrid.computeToolbarOpts;
      const {
        beforeQuery,
        afterQuery,
        beforeQueryFooter,
        afterQueryFooter,
        beforeDelete,
        afterDelete,
        beforeSave,
        afterSave,
        ajax = {}
      } = proxyOpts;
      const resConfigs = proxyOpts.response || proxyOpts.props || {};
      const $xeTable = $xeGrid.$refs.refTable;
      let formData = $xeGrid.getFormData();
      let button = null;
      let code = null;
      if (_xeUtils.default.isString(proxyTarget)) {
        const {
          buttons
        } = toolbarOpts;
        const matchObj = (toolbarConfig || toolbar) && (0, _utils.isEnableConf)(toolbarOpts) && buttons ? _xeUtils.default.findTree(buttons, item => item.code === proxyTarget, {
          children: 'dropdowns'
        }) : null;
        button = matchObj ? matchObj.item : null;
        code = proxyTarget;
      } else {
        button = proxyTarget;
        code = button.code;
      }
      const btnParams = button ? button.params : null;
      switch (code) {
        case 'insert':
          return $xeTable.insert({});
        case 'insert_edit':
          return $xeTable.insert({}).then(({
            row
          }) => $xeTable.setEditRow(row, true));
        // 已废弃
        case 'insert_actived':
          return $xeTable.insert({}).then(({
            row
          }) => $xeTable.setEditRow(row, true));
        // 已废弃
        case 'mark_cancel':
          $xeGrid.triggerPendingEvent(code);
          break;
        case 'remove':
          return $xeGrid.handleDeleteRow(code, 'vxe.grid.removeSelectRecord', () => $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':
          {
            const qMethods = ajax.query;
            const qsMethods = ajax.querySuccess;
            const qeMethods = ajax.queryError;
            if (qMethods) {
              const isInited = code === 'initial';
              const isReload = code === 'reload';
              if (!isInited && reactData.tableLoading) {
                return $xeGrid.$nextTick();
              }
              let operPromise = null;
              let sortList = [];
              let filterList = [];
              let 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 = $xeGrid.getDefaultFormData();
                  reactData.formData = formData;
                }
                if ($xeTable) {
                  const tableInternalData = $xeTable;
                  const {
                    tableFullColumn,
                    fullColumnFieldData
                  } = tableInternalData;
                  const sortOpts = $xeTable.computeSortOpts;
                  let defaultSort = sortOpts.defaultSort;
                  tableFullColumn.forEach(column => {
                    column.order = null;
                  });
                  // 如果使用默认排序
                  if (defaultSort) {
                    if (!_xeUtils.default.isArray(defaultSort)) {
                      defaultSort = [defaultSort];
                    }
                    sortList = defaultSort.map(item => {
                      const {
                        field,
                        order
                      } = item;
                      const colRest = fullColumnFieldData[field];
                      if (colRest) {
                        const column = colRest.column;
                        if (column) {
                          column.order = order;
                        }
                      }
                      return {
                        field,
                        property: field,
                        order
                      };
                    });
                  }
                  filterList = $xeTable.getCheckedFilters();
                }
              } else {
                if ($xeTable) {
                  if (isReload) {
                    operPromise = $xeTable.clearAll();
                  } else {
                    sortList = $xeTable.getSortColumns();
                    filterList = $xeTable.getCheckedFilters();
                  }
                }
              }
              const commitParams = {
                $table: $xeTable,
                $grid: $xeGrid,
                $gantt: null,
                code,
                button,
                isInited,
                isReload,
                page: pageParams,
                sort: sortList.length ? sortList[0] : {},
                sorts: sortList,
                filters: filterList,
                form: formData,
                options: qMethods
              };
              reactData.sortData = sortList;
              reactData.filterData = filterList;
              reactData.tableLoading = true;
              return Promise.all([Promise.resolve((beforeQuery || qMethods)(commitParams, ...args)), operPromise]).then(([rest]) => {
                let tableData = [];
                reactData.tableLoading = false;
                if (rest) {
                  const reParams = {
                    data: rest,
                    $table: $xeTable,
                    $grid: $xeGrid,
                    $gantt: null
                  };
                  if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts)) {
                    const totalProp = resConfigs.total;
                    const total = (_xeUtils.default.isFunction(totalProp) ? totalProp(reParams) : _xeUtils.default.get(rest, totalProp || 'page.total')) || 0;
                    tablePage.total = _xeUtils.default.toNumber(total);
                    const resultProp = resConfigs.result;
                    tableData = (_xeUtils.default.isFunction(resultProp) ? resultProp(reParams) : _xeUtils.default.get(rest, resultProp || 'result')) || [];
                    // 检验当前页码，不能超出当前最大页数
                    const pageCount = Math.max(Math.ceil(total / tablePage.pageSize), 1);
                    if (tablePage.currentPage > pageCount) {
                      tablePage.currentPage = pageCount;
                    }
                  } else {
                    const listProp = resConfigs.list;
                    if (_xeUtils.default.isArray(rest)) {
                      tableData = rest;
                    } else if (listProp) {
                      tableData = (_xeUtils.default.isFunction(listProp) ? listProp(reParams) : _xeUtils.default.get(rest, listProp)) || [];
                    }
                  }
                  if (showFooter) {
                    const fdProp = resConfigs.footerData;
                    const footerList = fdProp ? _xeUtils.default.isFunction(fdProp) ? fdProp(reParams) : _xeUtils.default.get(rest, fdProp) : [];
                    if (_xeUtils.default.isArray(footerList)) {
                      reactData.footerData = footerList;
                    }
                  }
                }
                if ($xeTable) {
                  $xeTable.loadData(tableData);
                } else {
                  $xeGrid.$nextTick(() => {
                    const $xeTable = $xeGrid.$refs.refTable;
                    if ($xeTable) {
                      $xeTable.loadData(tableData);
                    }
                  });
                }
                if (afterQuery) {
                  afterQuery(commitParams, ...args);
                }
                if (qsMethods) {
                  qsMethods(Object.assign(Object.assign({}, commitParams), {
                    response: rest
                  }));
                }
                return {
                  status: true
                };
              }).catch(rest => {
                reactData.tableLoading = false;
                if (qeMethods) {
                  qeMethods(Object.assign(Object.assign({}, commitParams), {
                    response: rest
                  }));
                }
                return {
                  status: false
                };
              });
            } else {
              (0, _log.errLog)('vxe.error.notFunc', ['[grid] proxy-config.ajax.query']);
            }
            break;
          }
        case 'queryFooter':
          {
            const qfMethods = ajax.queryFooter;
            const qfSuccessMethods = ajax.queryFooterSuccess;
            const qfErrorMethods = ajax.queryFooterError;
            if (qfMethods) {
              let filterList = [];
              if ($xeTable) {
                filterList = $xeTable.getCheckedFilters();
              }
              const commitParams = {
                $table: $xeTable,
                $grid: $xeGrid,
                $gantt: null,
                code,
                button,
                filters: filterList,
                form: formData,
                options: qfMethods
              };
              return Promise.resolve((beforeQueryFooter || qfMethods)(commitParams, ...args)).then(rest => {
                reactData.footerData = _xeUtils.default.isArray(rest) ? rest : [];
                if (afterQueryFooter) {
                  afterQueryFooter(commitParams, ...args);
                }
                if (qfSuccessMethods) {
                  qfSuccessMethods(Object.assign(Object.assign({}, commitParams), {
                    response: rest
                  }));
                }
                return {
                  status: true
                };
              }).catch(rest => {
                if (qfErrorMethods) {
                  qfErrorMethods(Object.assign(Object.assign({}, commitParams), {
                    response: rest
                  }));
                }
                return {
                  status: false
                };
              });
            } else {
              (0, _log.errLog)('vxe.error.notFunc', ['[grid] proxy-config.ajax.queryFooter']);
            }
            break;
          }
        case 'delete':
          {
            const dMethods = ajax.delete;
            const deleteSuccessMethods = ajax.deleteSuccess;
            const deleteErrorMethods = ajax.deleteError;
            if (dMethods) {
              const selectRecords = $xeTable.getCheckboxRecords();
              const removeRecords = selectRecords.filter(row => !$xeTable.isInsertByRow(row));
              const body = {
                removeRecords
              };
              const commitParams = {
                $table: $xeTable,
                $grid: $xeGrid,
                $gantt: null,
                code,
                button,
                body,
                form: formData,
                options: dMethods
              };
              const applyArgs = [commitParams].concat(args);
              if (selectRecords.length) {
                return $xeGrid.handleDeleteRow(code, 'vxe.grid.deleteSelectRecord', () => {
                  if (!removeRecords.length) {
                    return $xeTable.remove(selectRecords);
                  }
                  reactData.tableLoading = true;
                  return Promise.resolve((beforeDelete || dMethods)(...applyArgs)).then(rest => {
                    reactData.tableLoading = false;
                    $xeTable.setPendingRow(removeRecords, false);
                    if (isRespMsg) {
                      if (_ui.VxeUI.modal) {
                        _ui.VxeUI.modal.message({
                          content: $xeGrid.getRespMsg(rest, 'vxe.grid.delSuccess'),
                          status: 'success'
                        });
                      }
                    }
                    if (afterDelete) {
                      afterDelete(...applyArgs);
                    } else {
                      internalData.uFoot = true;
                      $xeGrid.commitProxy('query');
                      internalData.uFoot = false;
                      $xeGrid.updateQueryFooter();
                    }
                    if (deleteSuccessMethods) {
                      deleteSuccessMethods(Object.assign(Object.assign({}, commitParams), {
                        response: rest
                      }));
                    }
                    return {
                      status: true
                    };
                  }).catch(rest => {
                    reactData.tableLoading = false;
                    if (isRespMsg) {
                      if (_ui.VxeUI.modal) {
                        _ui.VxeUI.modal.message({
                          id: code,
                          content: $xeGrid.getRespMsg(rest, 'vxe.grid.operError'),
                          status: 'error'
                        });
                      }
                    }
                    if (deleteErrorMethods) {
                      deleteErrorMethods(Object.assign(Object.assign({}, commitParams), {
                        response: rest
                      }));
                    }
                    return {
                      status: false
                    };
                  });
                });
              } else {
                if (isActiveMsg) {
                  if (_ui.VxeUI.modal) {
                    _ui.VxeUI.modal.message({
                      id: code,
                      content: getI18n('vxe.grid.selectOneRecord'),
                      status: 'warning'
                    });
                  }
                }
              }
            } else {
              (0, _log.errLog)('vxe.error.notFunc', ['[grid] proxy-config.ajax.delete']);
            }
            break;
          }
        case 'save':
          {
            const ajaxMethods = ajax.save;
            const saveSuccessMethods = ajax.saveSuccess;
            const saveErrorMethods = ajax.saveError;
            if (ajaxMethods) {
              const body = $xeGrid.getRecordset();
              const {
                insertRecords,
                removeRecords,
                updateRecords,
                pendingRecords
              } = body;
              const commitParams = {
                $table: $xeTable,
                $grid: $xeGrid,
                $gantt: null,
                code,
                button,
                body,
                form: formData,
                options: ajaxMethods
              };
              const applyArgs = [commitParams].concat(args);
              // 排除掉新增且标记为删除的数据
              if (insertRecords.length) {
                body.pendingRecords = pendingRecords.filter(row => insertRecords.indexOf(row) === -1);
              }
              // 排除已标记为删除的数据
              if (pendingRecords.length) {
                body.insertRecords = insertRecords.filter(row => pendingRecords.indexOf(row) === -1);
              }
              let restPromise = Promise.resolve();
              if (editRules) {
                // 只校验新增和修改的数据
                restPromise = $xeGrid[validConfig && validConfig.msgMode === 'full' ? 'fullValidate' : 'validate'](body.insertRecords.concat(updateRecords));
              }
              return restPromise.then(errMap => {
                if (errMap) {
                  // 如果校验不通过
                  return;
                }
                if (body.insertRecords.length || removeRecords.length || updateRecords.length || body.pendingRecords.length) {
                  reactData.tableLoading = true;
                  return Promise.resolve((beforeSave || ajaxMethods)(...applyArgs)).then(rest => {
                    reactData.tableLoading = false;
                    $xeTable.clearPendingRow();
                    if (isRespMsg) {
                      if (_ui.VxeUI.modal) {
                        _ui.VxeUI.modal.message({
                          content: $xeGrid.getRespMsg(rest, 'vxe.grid.saveSuccess'),
                          status: 'success'
                        });
                      }
                    }
                    if (afterSave) {
                      afterSave(...applyArgs);
                    } else {
                      internalData.uFoot = true;
                      $xeGrid.commitProxy('query');
                      internalData.uFoot = false;
                      $xeGrid.updateQueryFooter();
                    }
                    if (saveSuccessMethods) {
                      saveSuccessMethods(Object.assign(Object.assign({}, commitParams), {
                        response: rest
                      }));
                    }
                    return {
                      status: true
                    };
                  }).catch(rest => {
                    reactData.tableLoading = false;
                    if (isRespMsg) {
                      if (_ui.VxeUI.modal) {
                        _ui.VxeUI.modal.message({
                          id: code,
                          content: $xeGrid.getRespMsg(rest, 'vxe.grid.operError'),
                          status: 'error'
                        });
                      }
                    }
                    if (saveErrorMethods) {
                      saveErrorMethods(Object.assign(Object.assign({}, commitParams), {
                        response: rest
                      }));
                    }
                    return {
                      status: false
                    };
                  });
                } else {
                  if (isActiveMsg) {
                    if (_ui.VxeUI.modal) {
                      _ui.VxeUI.modal.message({
                        id: code,
                        content: getI18n('vxe.grid.dataUnchanged'),
                        status: 'info'
                      });
                    }
                  }
                }
              });
            } else {
              (0, _log.errLog)('vxe.error.notFunc', ['[grid] proxy-config.ajax.save']);
            }
            break;
          }
        default:
          {
            const gCommandOpts = commands.get(code);
            if (gCommandOpts) {
              const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod;
              if (tCommandMethod) {
                tCommandMethod({
                  code,
                  button,
                  $grid: $xeGrid,
                  $table: $xeTable,
                  $gantt: null
                }, ...args);
              } else {
                (0, _log.errLog)('vxe.error.notCommands', [`[grid] ${code}`]);
              }
            }
          }
      }
      return $xeGrid.$nextTick();
    },
    getFormData() {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const {
        proxyConfig
      } = props;
      const {
        formData
      } = reactData;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const formOpts = $xeGrid.computeFormOpts;
      return proxyConfig && (0, _utils.isEnableConf)(proxyOpts) && proxyOpts.form ? formData : formOpts.data;
    },
    getFormItems(itemIndex) {
      const $xeGrid = this;
      const props = $xeGrid;
      const formOpts = $xeGrid.computeFormOpts;
      const {
        formConfig
      } = props;
      const {
        items
      } = formOpts;
      const itemList = [];
      _xeUtils.default.eachTree(formConfig && (0, _utils.isEnableConf)(formOpts) && items ? items : [], item => {
        itemList.push(item);
      }, {
        children: 'children'
      });
      return _xeUtils.default.isUndefined(itemIndex) ? itemList : itemList[itemIndex];
    },
    resetForm() {
      const $xeGrid = this;
      const $form = $xeGrid.$refs.refForm;
      if ($form) {
        return $form.reset();
      }
      return $xeGrid.$nextTick();
    },
    validateForm() {
      const $xeGrid = this;
      const $form = $xeGrid.$refs.refForm;
      if ($form) {
        return $form.validate();
      }
      return $xeGrid.$nextTick();
    },
    validateFormField(field) {
      const $xeGrid = this;
      const $form = $xeGrid.$refs.refForm;
      if ($form) {
        return $form.validateField(field);
      }
      return $xeGrid.$nextTick();
    },
    clearFormValidate(field) {
      const $xeGrid = this;
      const $form = $xeGrid.$refs.refForm;
      if ($form) {
        return $form.clearValidate(field);
      }
      return $xeGrid.$nextTick();
    },
    homePage() {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      const {
        tablePage
      } = reactData;
      tablePage.currentPage = 1;
      return $xeGrid.$nextTick();
    },
    homePageByEvent(evnt) {
      const $xeGrid = this;
      const $pager = $xeGrid.$refs.refPager;
      if ($pager) {
        $pager.homePageByEvent(evnt);
      }
    },
    endPage() {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      const {
        tablePage
      } = reactData;
      const pageCount = $xeGrid.computePageCount;
      tablePage.currentPage = pageCount;
      return $xeGrid.$nextTick();
    },
    endPageByEvent(evnt) {
      const $xeGrid = this;
      const $pager = $xeGrid.$refs.refPager;
      if ($pager) {
        $pager.endPageByEvent(evnt);
      }
    },
    getCurrentPage() {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      const {
        tablePage
      } = reactData;
      return tablePage.currentPage;
    },
    setCurrentPage(currentPage) {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      const {
        tablePage
      } = reactData;
      const pageCount = $xeGrid.computePageCount;
      tablePage.currentPage = Math.min(pageCount, Math.max(1, _xeUtils.default.toNumber(currentPage)));
      return $xeGrid.$nextTick();
    },
    setCurrentPageByEvent(evnt, currentPage) {
      const $xeGrid = this;
      const $pager = $xeGrid.$refs.refPager;
      if ($pager) {
        $pager.setCurrentPageByEvent(evnt, currentPage);
      }
    },
    getPageSize() {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      const {
        tablePage
      } = reactData;
      return tablePage.pageSize;
    },
    setPageSize(pageSize) {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      const {
        tablePage
      } = reactData;
      tablePage.pageSize = Math.max(1, _xeUtils.default.toNumber(pageSize));
      return $xeGrid.$nextTick();
    },
    setPageSizeByEvent(evnt, pageSize) {
      const $xeGrid = this;
      const $pager = $xeGrid.$refs.refPager;
      if ($pager) {
        $pager.setPageSizeByEvent(evnt, pageSize);
      }
    },
    triggerToolbarCommitEvent(params, evnt) {
      const $xeGrid = this;
      const internalData = $xeGrid.internalData;
      const {
        code
      } = params;
      if (code) {
        const isUf = ['reload', 'delete', 'save'].includes(code);
        if (isUf) {
          internalData.uFoot = true;
        }
        const rest = $xeGrid.commitProxy(params, evnt).then(rest => {
          if (code && rest && rest.status && ['query', 'reload', 'delete', 'save'].includes(code)) {
            $xeGrid.dispatchEvent(code === 'delete' || code === 'save' ? `proxy-${code}` : 'proxy-query', Object.assign(Object.assign({}, rest), {
              isReload: code === 'reload'
            }), evnt);
          }
        });
        if (isUf) {
          $xeGrid.updateQueryFooter();
        }
        internalData.uFoot = false;
        return rest;
      }
      return $xeGrid.$nextTick();
    },
    triggerToolbarBtnEvent(button, evnt) {
      const $xeGrid = this;
      $xeGrid.triggerToolbarCommitEvent(button, evnt);
      $xeGrid.dispatchEvent('toolbar-button-click', {
        code: button.code,
        button
      }, evnt);
    },
    triggerToolbarTolEvent(tool, evnt) {
      const $xeGrid = this;
      $xeGrid.triggerToolbarCommitEvent(tool, evnt);
      $xeGrid.dispatchEvent('toolbar-tool-click', {
        code: tool.code,
        tool
      }, evnt);
    },
    pageChangeEvent(params) {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const {
        proxyConfig
      } = props;
      const {
        tablePage
      } = reactData;
      const {
        $event,
        currentPage,
        pageSize
      } = params;
      const proxyOpts = $xeGrid.computeProxyOpts;
      tablePage.currentPage = currentPage;
      tablePage.pageSize = pageSize;
      $xeGrid.dispatchEvent('page-change', params, $event);
      if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
        $xeGrid.commitProxy('query').then(rest => {
          $xeGrid.dispatchEvent('proxy-query', rest, $event);
        });
      }
    },
    handleSortEvent(params) {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const $xeTable = $xeGrid.$refs.refTable;
      const {
        proxyConfig
      } = props;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const sortOpts = $xeTable.computeSortOpts;
      // 如果是服务端排序
      if (sortOpts.remote) {
        reactData.sortData = params.sortList;
        if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
          reactData.tablePage.currentPage = 1;
          $xeGrid.commitProxy('query').then(rest => {
            $xeGrid.dispatchEvent('proxy-query', rest, params.$event);
          });
        }
      }
    },
    sortChangeEvent(params) {
      const $xeGrid = this;
      $xeGrid.handleSortEvent(params);
      $xeGrid.dispatchEvent('sort-change', params, params.$event);
    },
    clearAllSortEvent(params) {
      const $xeGrid = this;
      $xeGrid.handleSortEvent(params);
      $xeGrid.dispatchEvent('clear-all-sort', params, params.$event);
    },
    handleFilterEvent(params) {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const internalData = $xeGrid.internalData;
      const $xeTable = $xeGrid.$refs.refTable;
      const {
        proxyConfig
      } = props;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const filterOpts = $xeTable.computeFilterOpts;
      // 如果是服务端过滤
      if (filterOpts.remote) {
        reactData.filterData = params.filterList;
        if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
          reactData.tablePage.currentPage = 1;
          internalData.uFoot = true;
          $xeGrid.commitProxy('query').then(rest => {
            $xeGrid.dispatchEvent('proxy-query', rest, params.$event);
          });
          internalData.uFoot = false;
          $xeGrid.updateQueryFooter();
        }
      }
    },
    filterChangeEvent(params) {
      const $xeGrid = this;
      $xeGrid.handleFilterEvent(params);
      $xeGrid.dispatchEvent('filter-change', params, params.$event);
    },
    clearAllFilterEvent(params) {
      const $xeGrid = this;
      $xeGrid.handleFilterEvent(params);
      $xeGrid.dispatchEvent('clear-all-filter', params, params.$event);
    },
    submitFormEvent(params) {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const internalData = $xeGrid.internalData;
      const {
        proxyConfig
      } = props;
      const proxyOpts = $xeGrid.computeProxyOpts;
      if (reactData.tableLoading) {
        return;
      }
      if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
        internalData.uFoot = true;
        $xeGrid.commitProxy('reload').then(rest => {
          $xeGrid.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), {
            isReload: true
          }), params.$event);
        });
        internalData.uFoot = false;
        $xeGrid.updateQueryFooter();
      }
      $xeGrid.dispatchEvent('form-submit', params, params.$event);
    },
    resetFormEvent(params) {
      const $xeGrid = this;
      const props = $xeGrid;
      const internalData = $xeGrid.internalData;
      const $xeTable = $xeGrid.$refs.refTable;
      const {
        proxyConfig
      } = props;
      const {
        $event
      } = params;
      const proxyOpts = $xeGrid.computeProxyOpts;
      if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
        $xeTable.clearScroll();
        internalData.uFoot = true;
        $xeGrid.commitProxy('reload').then(rest => {
          $xeGrid.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), {
            isReload: true
          }), $event);
        });
        internalData.uFoot = false;
        $xeGrid.updateQueryFooter();
      }
      $xeGrid.dispatchEvent('form-reset', params, $event);
    },
    submitInvalidEvent(params) {
      const $xeGrid = this;
      $xeGrid.dispatchEvent('form-submit-invalid', params, params.$event);
    },
    collapseEvent(params) {
      const $xeGrid = this;
      const {
        $event
      } = params;
      $xeGrid.dispatchEvent('form-toggle-collapse', params, $event);
      $xeGrid.dispatchEvent('form-collapse', params, $event);
    },
    triggerZoomEvent(evnt) {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      $xeGrid.zoom();
      $xeGrid.dispatchEvent('zoom', {
        type: reactData.isZMax ? 'max' : 'revert'
      }, evnt);
    },
    getParams() {
      const $xeGrid = this;
      const props = $xeGrid;
      return props.params;
    },
    zoom() {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      if (reactData.isZMax) {
        return $xeGrid.revert();
      }
      return $xeGrid.maximize();
    },
    isMaximized() {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      return reactData.isZMax;
    },
    maximize() {
      const $xeGrid = this;
      return $xeGrid.handleZoom(true);
    },
    revert() {
      const $xeGrid = this;
      return $xeGrid.handleZoom();
    },
    handleZoom(isMax) {
      const $xeGrid = this;
      const reactData = $xeGrid.reactData;
      const {
        isZMax
      } = reactData;
      if (isMax ? !isZMax : isZMax) {
        reactData.isZMax = !isZMax;
        if (reactData.tZindex < (0, _utils.getLastZIndex)()) {
          reactData.tZindex = (0, _utils.nextZIndex)();
        }
      }
      return $xeGrid.$nextTick().then(() => $xeGrid.recalculate(true)).then(() => {
        setTimeout(() => $xeGrid.recalculate(true), 15);
        return reactData.isZMax;
      });
    },
    getProxyInfo() {
      const $xeGrid = this;
      const props = $xeGrid;
      const $xeTable = $xeGrid.$refs.refTable;
      const reactData = $xeGrid.reactData;
      if (props.proxyConfig) {
        const {
          sortData
        } = reactData;
        return {
          data: $xeTable ? $xeTable.getFullData() : [],
          filter: reactData.filterData,
          form: $xeGrid.getFormData(),
          sort: sortData.length ? sortData[0] : {},
          sorts: sortData,
          pager: reactData.tablePage,
          pendingRecords: $xeTable ? $xeTable.getPendingRecords() : []
        };
      }
      return null;
    },
    loadColumn(columns) {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      const $xeTable = $xeGrid.$refs.refTable;
      _xeUtils.default.eachTree(columns, column => {
        if (column.slots) {
          _xeUtils.default.each(column.slots, func => {
            if (!_xeUtils.default.isFunction(func)) {
              if (!slots[func]) {
                (0, _log.errLog)('vxe.error.notSlot', [`[grid] ${func}`]);
              }
            }
          });
        }
      });
      return $xeTable.loadColumn(columns);
    },
    reloadColumn(columns) {
      const $xeGrid = this;
      $xeGrid.clearAll();
      return $xeGrid.loadColumn(columns);
    },
    getConfigSlot(slotConfigs) {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      const slotConf = {};
      _xeUtils.default.objectMap(slotConfigs, (slotFunc, slotKey) => {
        if (slotFunc) {
          if (_xeUtils.default.isString(slotFunc)) {
            if (slots[slotFunc]) {
              slotConf[slotKey] = slots[slotFunc];
            } else {
              (0, _log.errLog)('vxe.error.notSlot', [`[grid] ${slotFunc}`]);
            }
          } else {
            slotConf[slotKey] = slotFunc;
          }
        }
      });
      return slotConf;
    },
    getToolbarSlots() {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      const toolbarOpts = $xeGrid.computeToolbarOpts;
      const toolbarOptSlots = toolbarOpts.slots;
      const toolbarSlots = {};
      if (slots.buttons && (!toolbarOptSlots || toolbarOptSlots.buttons !== 'buttons')) {
        (0, _log.warnLog)('vxe.error.reqProp', ['[grid] toolbar-config.slots.buttons']);
      }
      if (slots.tools && (!toolbarOptSlots || toolbarOptSlots.tools !== 'tools')) {
        (0, _log.warnLog)('vxe.error.reqProp', ['[grid] toolbar-config.slots.tools']);
      }
      if (toolbarOptSlots) {
        const buttonsSlot = $xeGrid.getFuncSlot(toolbarOptSlots, 'buttons');
        const buttonPrefixSlot = $xeGrid.getFuncSlot(toolbarOptSlots, 'buttonPrefix');
        const buttonSuffixSlot = $xeGrid.getFuncSlot(toolbarOptSlots, 'buttonSuffix');
        const toolsSlot = $xeGrid.getFuncSlot(toolbarOptSlots, 'tools');
        const toolPrefixSlot = $xeGrid.getFuncSlot(toolbarOptSlots, 'toolPrefix');
        const toolSuffixSlot = $xeGrid.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(optSlots, slotKey) {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      const funcSlot = optSlots[slotKey];
      if (funcSlot) {
        if (_xeUtils.default.isString(funcSlot)) {
          if (slots[funcSlot]) {
            return slots[funcSlot];
          } else {
            (0, _log.errLog)('vxe.error.notSlot', [`[grid] ${funcSlot}`]);
          }
        } else {
          return funcSlot;
        }
      }
      return null;
    },
    //
    // Render
    //
    renderDefaultForm(h) {
      const VxeUIFormComponent = _ui.VxeUI.getComponent('VxeForm');
      const $xeGrid = this;
      const props = $xeGrid;
      const slots = $xeGrid.$scopedSlots;
      const reactData = $xeGrid.reactData;
      const {
        proxyConfig,
        formConfig
      } = props;
      const {
        formData
      } = reactData;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const formOpts = $xeGrid.computeFormOpts;
      if ((0, _utils.isEnableConf)(formConfig) && formOpts.items && formOpts.items.length) {
        const formSlots = {};
        if (!formOpts.inited) {
          formOpts.inited = true;
          const beforeItem = proxyOpts.beforeItem;
          if (proxyOpts && beforeItem) {
            formOpts.items.forEach(item => {
              beforeItem.call($xeGrid, {
                $grid: $xeGrid,
                $gantt: null,
                item
              });
            });
          }
        }
        // 处理插槽
        formOpts.items.forEach(item => {
          _xeUtils.default.each(item.slots, 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: $xeGrid.submitFormEvent,
            reset: $xeGrid.resetFormEvent,
            collapse: $xeGrid.collapseEvent,
            'submit-invalid': $xeGrid.submitInvalidEvent
          },
          scopedSlots: formSlots
        }) : renderEmptyElement($xeGrid)];
      }
      return [];
    },
    renderForm(h) {
      const $xeGrid = this;
      const props = $xeGrid;
      const slots = $xeGrid.$scopedSlots;
      const {
        formConfig
      } = props;
      const formSlot = slots.form;
      const hasForm = !!(formSlot || (0, _utils.isEnableConf)(formConfig));
      if (hasForm) {
        return h('div', {
          key: 'form',
          ref: 'refFormWrapper',
          class: 'vxe-grid--form-wrapper'
        }, formSlot ? formSlot.call($xeGrid, {
          $grid: $xeGrid,
          $gantt: null
        }) : $xeGrid.renderDefaultForm(h));
      }
      return renderEmptyElement($xeGrid);
    },
    renderToolbar(h) {
      const $xeGrid = this;
      const props = $xeGrid;
      const slots = $xeGrid.$scopedSlots;
      const {
        toolbarConfig
      } = props;
      const toolbarSlot = slots.toolbar;
      const toolbarOpts = $xeGrid.computeToolbarOpts;
      if (toolbarConfig && (0, _utils.isEnableConf)(toolbarOpts) || toolbarSlot) {
        return h('div', {
          key: 'toolbar',
          ref: 'refToolbarWrapper',
          class: 'vxe-grid--toolbar-wrapper'
        }, toolbarSlot ? toolbarSlot.call($xeGrid, {
          $grid: $xeGrid,
          $gantt: null
        }) : [h(_toolbar.default, {
          props: Object.assign({}, toolbarOpts, {
            slots: undefined
          }),
          ref: 'refToolbar',
          scopedSlots: $xeGrid.getToolbarSlots()
        })]);
      }
      return renderEmptyElement($xeGrid);
    },
    renderTop(h) {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      const topSlot = slots.top;
      return topSlot ? h('div', {
        key: 'top',
        ref: 'refTopWrapper',
        class: 'vxe-grid--top-wrapper'
      }, topSlot.call($xeGrid, {
        $grid: $xeGrid,
        $gantt: null
      })) : renderEmptyElement($xeGrid);
    },
    renderTableLeft(h) {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      const leftSlot = slots.left;
      if (leftSlot) {
        return h('div', {
          class: 'vxe-grid--left-wrapper'
        }, leftSlot({
          $grid: $xeGrid,
          $gantt: null
        }));
      }
      return renderEmptyElement($xeGrid);
    },
    renderTableRight(h) {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      const rightSlot = slots.right;
      if (rightSlot) {
        return h('div', {
          class: 'vxe-grid--right-wrapper'
        }, rightSlot({
          $grid: $xeGrid,
          $gantt: null
        }));
      }
      return renderEmptyElement($xeGrid);
    },
    renderTable(h) {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      const tableProps = $xeGrid.computeTableProps;
      return h('div', {
        class: 'vxe-grid--table-wrapper'
      }, [h(_table.default, {
        key: 'table',
        props: tableProps,
        on: getTableOns($xeGrid),
        scopedSlots: slots,
        ref: 'refTable'
      })]);
    },
    renderBottom(h) {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      const bottomSlot = slots.bottom;
      return bottomSlot ? h('div', {
        key: 'bottom',
        ref: 'refBottomWrapper',
        class: 'vxe-grid--bottom-wrapper'
      }, bottomSlot.call($xeGrid, {
        $grid: $xeGrid,
        $gantt: null
      })) : renderEmptyElement($xeGrid);
    },
    renderPager(h) {
      const VxeUIPagerComponent = _ui.VxeUI.getComponent('VxePager');
      const $xeGrid = this;
      const props = $xeGrid;
      const slots = $xeGrid.$scopedSlots;
      const reactData = $xeGrid.reactData;
      const {
        proxyConfig,
        pagerConfig
      } = props;
      const proxyOpts = $xeGrid.computeProxyOpts;
      const pagerOpts = $xeGrid.computePagerOpts;
      const pagerSlot = slots.pager;
      if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts) || slots.pager) {
        return h('div', {
          ref: 'refPagerWrapper',
          key: 'pager',
          class: 'vxe-grid--pager-wrapper'
        }, pagerSlot ? pagerSlot.call($xeGrid, {
          $grid: $xeGrid,
          $gantt: null
        }) : [VxeUIPagerComponent ? h(VxeUIPagerComponent, {
          ref: 'refPager',
          props: Object.assign(Object.assign({}, pagerOpts), proxyConfig && (0, _utils.isEnableConf)(proxyOpts) ? reactData.tablePage : {}),
          on: {
            'page-change': $xeGrid.pageChangeEvent
          },
          scopedSlots: $xeGrid.getConfigSlot(pagerOpts.slots)
        }) : renderEmptyElement($xeGrid)]);
      }
      return renderEmptyElement($xeGrid);
    },
    renderChildLayout(h, layoutKeys) {
      const $xeGrid = this;
      const childVNs = [];
      layoutKeys.forEach(key => {
        switch (key) {
          case 'Form':
            childVNs.push($xeGrid.renderForm(h));
            break;
          case 'Toolbar':
            childVNs.push($xeGrid.renderToolbar(h));
            break;
          case 'Top':
            childVNs.push($xeGrid.renderTop(h));
            break;
          case 'Table':
            childVNs.push(h('div', {
              key: 'table',
              class: 'vxe-grid--table-container'
            }, [$xeGrid.renderTableLeft(h), $xeGrid.renderTable(h), $xeGrid.renderTableRight(h)]));
            break;
          case 'Bottom':
            childVNs.push($xeGrid.renderBottom(h));
            break;
          case 'Pager':
            childVNs.push($xeGrid.renderPager(h));
            break;
          default:
            (0, _log.errLog)('vxe.error.notProp', [`[grid] layouts -> ${key}`]);
            break;
        }
      });
      return childVNs;
    },
    renderLayout(h) {
      const $xeGrid = this;
      const slots = $xeGrid.$scopedSlots;
      const currLayoutConf = $xeGrid.computeCurrLayoutConf;
      const {
        headKeys,
        bodyKeys,
        footKeys
      } = currLayoutConf;
      const asideLeftSlot = slots.asideLeft || slots['aside-left'];
      const asideRightSlot = slots.asideRight || slots['aside-right'];
      return [h('div', {
        class: 'vxe-grid--layout-header-wrapper'
      }, $xeGrid.renderChildLayout(h, headKeys)), h('div', {
        class: 'vxe-grid--layout-body-wrapper'
      }, [asideLeftSlot ? h('div', {
        class: 'vxe-grid--layout-aside-left-wrapper'
      }, asideLeftSlot({})) : renderEmptyElement($xeGrid), h('div', {
        class: 'vxe-grid--layout-body-content-wrapper'
      }, $xeGrid.renderChildLayout(h, bodyKeys)), asideRightSlot ? h('div', {
        class: 'vxe-grid--layout-aside-right-wrapper'
      }, asideRightSlot({})) : renderEmptyElement($xeGrid)]), h('div', {
        class: 'vxe-grid--layout-footer-wrapper'
      }, $xeGrid.renderChildLayout(h, footKeys)), h('div', {
        ref: 'refPopupContainerElem'
      })];
    },
    renderVN(h) {
      const $xeGrid = this;
      const props = $xeGrid;
      const reactData = $xeGrid.reactData;
      const vSize = $xeGrid.computeSize;
      const styles = $xeGrid.computeStyles;
      const isLoading = $xeGrid.computeIsLoading;
      return h('div', {
        ref: 'refElem',
        class: ['vxe-grid', {
          [`size--${vSize}`]: vSize,
          'is--animat': !!props.animat,
          'is--round': props.round,
          'is--maximize': reactData.isZMax,
          'is--loading': isLoading
        }],
        style: styles
      }, $xeGrid.renderLayout(h));
    }
  }),
  created() {
    // 使用已安装的组件，如果未安装则不渲染
    const VxeUIFormComponent = _ui.VxeUI.getComponent('VxeForm');
    const VxeUIPagerComponent = _ui.VxeUI.getComponent('VxePager');
    const $xeGrid = this;
    const props = $xeGrid;
    const proxyOpts = $xeGrid.computeProxyOpts;
    // const { data, formOpts, proxyOpts, proxyConfig } = this
    // if (proxyConfig && (data || (proxyOpts.form && formOpts.data))) {
    //   errLog('vxe.error.errConflicts', ['[grid] data', 'proxy-config'])
    // }
    if (props.toolbar) {
      (0, _log.errLog)('vxe.error.delProp', ['[grid] toolbar', 'toolbar-config']);
    }
    if (props.toolbarConfig && !_xeUtils.default.isObject(props.toolbarConfig)) {
      (0, _log.errLog)('vxe.error.errProp', [`[grid] toolbar-config=${props.toolbarConfig}`, 'toolbar-config={}']);
    }
    if (proxyOpts.props) {
      (0, _log.warnLog)('vxe.error.delProp', ['[grid] proxy-config.props', 'proxy-config.response']);
    }
    $xeGrid.$nextTick(() => {
      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']);
        }
      }
    });
    $xeGrid.initPages();
    globalEvents.on($xeGrid, 'keydown', $xeGrid.handleGlobalKeydownEvent);
  },
  mounted() {
    const $xeGrid = this;
    const props = $xeGrid;
    const {
      columns
    } = props;
    if (columns && columns.length) {
      $xeGrid.loadColumn(columns);
    }
    $xeGrid.initToolbar();
    $xeGrid.initProxy();
  },
  destroyed() {
    const $xeGrid = this;
    const internalData = $xeGrid.internalData;
    globalEvents.off($xeGrid, 'keydown');
    _xeUtils.default.assign(internalData, createInternalData());
  },
  render(h) {
    return this.renderVN(h);
  }
});
/* define-vxe-component end */