vue-ant-patterns/biz-lib/b-tree/index.js

vue-ant-patterns

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.defaultProps = undefined;

var _babelHelperVueJsxMergeProps = require('babel-helper-vue-jsx-merge-props');

var _babelHelperVueJsxMergeProps2 = _interopRequireDefault(_babelHelperVueJsxMergeProps);

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _dSwitchTree = require('../../lib/d-switch-tree');

var _dSwitchTree2 = _interopRequireDefault(_dSwitchTree);

var _dContainer = require('../../lib/d-container');

var _dContainer2 = _interopRequireDefault(_dContainer);

var _classnames = require('classnames');

var _classnames2 = _interopRequireDefault(_classnames);

var _antDesignVue = require('ant-design-vue');

var _propsUtil = require('ant-design-vue/lib/_util/props-util');

var _utils = require('../../lib/_utils');

var _extend = require('extend');

var _extend2 = _interopRequireDefault(_extend);

var _moment = require('moment');

var _moment2 = _interopRequireDefault(_moment);

var _request = require('../_biz-utils/request');

var _request2 = _interopRequireDefault(_request);

var _treeHeader = require('./treeHeader');

var _treeHeader2 = _interopRequireDefault(_treeHeader);

var _action = require('./action');

var _action2 = _interopRequireDefault(_action);

var _search = require('./search');

var _search2 = _interopRequireDefault(_search);

var _drag = require('./drag');

var _drag2 = _interopRequireDefault(_drag);

var _utils2 = require('./utils');

var _defaultProps = require('./defaultProps');

var _defaultProps2 = _interopRequireDefault(_defaultProps);

var _bizUtils = require('../_biz-utils');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var Horizontal = _dContainer2['default'].Horizontal,
    Vertical = _dContainer2['default'].Vertical;

var noop = function noop() {};

var nowDate = null;

var BTree = {
  name: 'BTree',
  mixins: [_search2['default'], _drag2['default'], _action2['default']],
  props: (0, _extends3['default'])({}, _defaultProps2['default']),
  model: {
    prop: 'selectedKeys',
    event: 'selectChange'
  },
  // 不需要响应的数据
  noResponseData: {},
  // 查询过子节点的父节点缓存
  loadedCache: {},
  vOpenKeysCache: [],
  created: function created() {
    var _$props = this.$props,
        rel = _$props.rel,
        dataSource = _$props.dataSource,
        dimensionOptions = _$props.dimensionOptions;

    if (dataSource) {
      this.treeData = (0, _utils.listToTree)(dataSource, {}, { rel: rel });
      return;
    }
  },
  destroyed: function destroyed() {
    this.resetState();
  },

  computed: {},
  data: function data() {
    var _$props2 = this.$props,
        defaultOpenKeys = _$props2.defaultOpenKeys,
        openKeys = _$props2.openKeys,
        defaultSelectedKeys = _$props2.defaultSelectedKeys,
        selectedKeys = _$props2.selectedKeys,
        dateOptions = _$props2.dateOptions,
        checkedKeys = _$props2.checkedKeys,
        rel = _$props2.rel,
        dimensionOptions = _$props2.dimensionOptions;
    var treeData = this.treeData;

    var vOpenKeys = [];
    var vSelectedKeys = [];
    var vCheckedKeys = [];
    var vDateUnix = 0;
    var format = '';
    var dateFormat = '';
    var isRequestSuccess = treeData && treeData.length;
    var getSubDispatchInitialEvent = true;

    var nowDate = (0, _moment2['default'])(Date.now()).startOf('day');
    var vDateVal = (0, _moment2['default'])(new Date()).startOf('day');

    var dateDisabled = false;
    var dimensionDisabled = false;
    var dimensionValue = '';

    // const rootNode = isRequestSuccess ? treeData[0] : [];

    if ((0, _propsUtil.hasProp)(this, 'defaultOpenKeys')) {
      vOpenKeys = defaultOpenKeys;
    }
    if ((0, _propsUtil.hasProp)(this, 'openKeys')) {
      vOpenKeys = [].concat((0, _toConsumableArray3['default'])(new Set([].concat((0, _toConsumableArray3['default'])(vOpenKeys), (0, _toConsumableArray3['default'])(openKeys)))));
    }
    // else if (isRequestSuccess) {
    //   vOpenKeys = [rootNode[rel[0]]];
    //   this.$emit('update:openKeys', vOpenKeys);
    // }
    if ((0, _propsUtil.hasProp)(this, 'defaultSelectedKeys')) {
      vSelectedKeys = defaultSelectedKeys;
    }
    if ((0, _propsUtil.hasProp)(this, 'selectedKeys')) {
      vSelectedKeys = [].concat((0, _toConsumableArray3['default'])(new Set([].concat((0, _toConsumableArray3['default'])(vSelectedKeys), (0, _toConsumableArray3['default'])(selectedKeys)))));
    }
    // else if (isRequestSuccess) {
    //   vSelectedKeys = [rootNode[rel[0]]];
    //   this.$emit('selectChange', vSelectedKeys);
    // }

    if ((0, _propsUtil.hasProp)(this, 'checkedKeys')) {
      vCheckedKeys = checkedKeys;
    }
    if (dimensionOptions) {
      var dimensionOps = (0, _extend2['default'])(true, {}, dimensionOps, dimensionOptions);
      if (dimensionOps.hasOwnProperty('disabled')) {
        dimensionDisabled = dimensionOps.disabled;
      }
      if (dimensionOptions.hasOwnProperty('defaultValue')) {
        dimensionValue = dimensionOptions.defaultValue;
      }
    }
    if (!dimensionValue) {
      dimensionValue = _defaultProps.dimensionDefaultOps.defaultValue;
    }
    if (dateOptions) {
      var dateOps = (0, _extend2['default'])(true, {}, _defaultProps.dateDefault, dateOptions);
      var onlyDate = dateOps.onlyDate,
          dateVal = dateOps.value,
          dateType = dateOps.type,
          dateDefauleValue = dateOps.defaultValue;

      if (dateOps.hasOwnProperty('disabled')) {
        dateDisabled = dateOps.disabled;
      }
      if (dateOps.format) {
        format = dateOps.format;
      }

      dateFormat = (0, _bizUtils.getCache)('dateFormat');

      if (!dateFormat && format) {
        (0, _bizUtils.setForName)(format, 'dateFormat');
      }

      if (dateDefauleValue) {
        vDateVal = (0, _moment2['default'])(dateDefauleValue);
      } else if (dateVal && dateVal !== 'now') {
        vDateVal = (0, _moment2['default'])(dateVal);
      }
      vDateUnix = vDateVal.valueOf();
    }

    if (!vDateUnix) {
      vDateUnix = nowDate.valueOf();
    }

    var vLoad = undefined;

    if ((0, _propsUtil.hasProp)(this, 'loadData')) {
      if (typeof loadData === 'boolean' && loadData === true) {
        vLoad = this.getCategoryItemChildren;
      } else if (typeof loadData === 'boolean' && loadData === false) {
        vLoad = undefined;
      }
    } else {
      vLoad = this.getCategoryItemChildren;
    }

    /**
     * vOpenKeys 展开项 与 loadData 异步加载子节点处理函数, 任一项为假
     * 则认为不需要异步加载子节点
     * 异步加载子节点前置条件为, 展开项 `vOpenKeys` 与 加载方法 `loadData`
     * 在之后的触发 initialEvent 中, 会使用他来判断触发事件时机
     */
    if (!vOpenKeys || !vOpenKeys.length || !vLoad) {
      getSubDispatchInitialEvent = false;
    }

    return {
      locale: 'zh-cn',
      listData: [],
      treeData: [],
      nowDate: nowDate,
      format: format || dateFormat || 'YYYY-MM-DD',
      // tree 请求节点数据缓存
      dataMap: {},
      // 通过 list 转成 符合树结构的 list
      // treeData: [],
      vSelectedKeys: vSelectedKeys,
      // tree 展开项
      vOpenKeys: vOpenKeys,
      // checked
      vCheckedKeys: vCheckedKeys,
      // 日期
      vDateVal: vDateVal,
      vDateUnix: vDateUnix,
      // 用于控制日期控件开启关闭
      dataPickerOpen: false,
      // 是否加载数据
      // isAsyncLoading: false,
      // 维度列表
      dimensionData: [],
      // 维度默认选中
      dimensionValue: dimensionValue,

      vLoadData: vLoad,
      getSubDispatchInitialEvent: getSubDispatchInitialEvent,
      init: true,

      dateDisabled: dateDisabled,
      dimensionDisabled: dimensionDisabled,
      filterValue: ''
    };
  },

  watch: {
    selectedKeys: function selectedKeys(_selectedKeys) {
      this.vSelectedKeys = _selectedKeys;
    },
    openKeys: function openKeys(_openKeys) {
      this.vOpenKeys = _openKeys;
    },
    vSelectedKeys: function vSelectedKeys(selectedKeys) {
      this.$emit('selectChange', selectedKeys);
    },
    vOpenKeys: function vOpenKeys(expandedKeys) {
      this.$emit('update:openKeys', expandedKeys);
    },
    checkedKeys: function checkedKeys(_checkedKeys) {
      this.vCheckedKeys = _checkedKeys;
    },
    vCheckedKeys: function vCheckedKeys(checkedKeys) {
      this.$emit('update:checkedKeys', checkedKeys);
    },
    listData: function listData(_listData) {
      var rel = this.$props.rel;

      this.treeData = (0, _utils.listToTree)(_listData, [], { rel: rel });
    }
  },
  mounted: function mounted() {
    var _this = this;

    var dimensionOptions = this.$props.dimensionOptions;

    this.resetOptions();
    if (!dimensionOptions) {
      this.getTreeRoot().then(function () {
        _this.initialEventHandler();
      });
    }
  },

  methods: {
    getListData: function getListData() {
      return (0, _utils.treeToList)(this.treeData);
    },
    getTreeSub: function () {
      var _ref = (0, _asyncToGenerator3['default'])( /*#__PURE__*/_regenerator2['default'].mark(function _callee(queryParamsObj) {
        return _regenerator2['default'].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return (0, _request2['default'])(queryParamsObj);

              case 2:
                return _context.abrupt('return', _context.sent);

              case 3:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function getTreeSub(_x) {
        return _ref.apply(this, arguments);
      }

      return getTreeSub;
    }(),
    getTreeRoot: function () {
      var _ref2 = (0, _asyncToGenerator3['default'])( /*#__PURE__*/_regenerator2['default'].mark(function _callee2() {
        var _$props3, rel, requestParam, renderKey, defaultSelectedKeys, selectedKeys, vSelectedKeys, queryParam, res, resData, code, msg, data;

        return _regenerator2['default'].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _$props3 = this.$props, rel = _$props3.rel, requestParam = _$props3.requestParam, renderKey = _$props3.renderKey, defaultSelectedKeys = _$props3.defaultSelectedKeys, selectedKeys = _$props3.selectedKeys;
                vSelectedKeys = this.vSelectedKeys;
                queryParam = (0, _extend2['default'])({}, requestParam);

                if ((0, _utils.isEmptyObj)(requestParam)) {
                  queryParam = paramObj;
                }
                // 后台提供的获取根节点, 与子节点 api 为不同的接口
                // 需要联调时调整
                // if (queryParamsObj) {
                //   queryParam.data = queryParamsObj;
                //   if (queryParamsObj.eventKey) {s
                //     // eventK = queryParamsObj.eventKey;
                //     delete queryParamsObj.eventKey;
                //   }
                // } else {
                queryParam.data = this.getRequestParams();
                // }
                _context2.next = 7;
                return (0, _request2['default'])(queryParam);

              case 7:
                res = _context2.sent;
                resData = res.data;
                code = resData.code, msg = resData.msg, data = resData.data;

                /**
                 * 初步分析, 返回数据中 下的几个属性含义
                 * hasCheckbox: false, 复选框
                 * loadable: true, 有子节点, 可加载
                 * selectable: true, 可选择
                 */

                if (code === 200) {
                  this.listData = this.setTreeData(data);
                  if (data && data.length && (!this.vOpenKeys || !this.vOpenKeys.length)) {
                    this.vOpenKeys = [].concat((0, _toConsumableArray3['default'])(new Set([].concat((0, _toConsumableArray3['default'])(this.vOpenKeys), [(0, _utils.relationHandler)(rel[0], data[0])]))));
                    // if (!vSelectedKeys.length) {
                    //   this.vSelectedKeys = [relationHandler(rel[0], data[0])];
                    // }
                    // this.$emit('selectChange', vSelectedKeys);
                  }
                } else {
                  this.$message.error(msg);
                }
                return _context2.abrupt('return', resData);

              case 12:
              case 'end':
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function getTreeRoot() {
        return _ref2.apply(this, arguments);
      }

      return getTreeRoot;
    }(),
    getDimension: function () {
      var _ref3 = (0, _asyncToGenerator3['default'])( /*#__PURE__*/_regenerator2['default'].mark(function _callee3() {
        var dimensionOptions, dimensionOps, defaultValue, url, method, reqParams, res;
        return _regenerator2['default'].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                dimensionOptions = this.$props.dimensionOptions;
                dimensionOps = (0, _extend2['default'])(true, {}, dimensionOps, dimensionOptions);
                defaultValue = dimensionOps.defaultValue, url = dimensionOps.url, method = dimensionOps.method;

                this.dimensionValue = defaultValue;
                this.$root.isLoading = true;
                reqParams = {
                  url: url,
                  method: method
                };
                _context3.next = 8;
                return (0, _request2['default'])(reqParams);

              case 8:
                res = _context3.sent;
                return _context3.abrupt('return', res);

              case 10:
              case 'end':
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function getDimension() {
        return _ref3.apply(this, arguments);
      }

      return getDimension;
    }(),
    updateOpenKeys: function updateOpenKeys(expandedKeys) {
      this.$emit('update:openKeys', expandedKeys);
    },

    // 收起展开
    onExpand: function onExpand(args) {
      var expandedKeys = args.expandedKeys;

      this.vOpenKeys = [].concat((0, _toConsumableArray3['default'])(expandedKeys));
      this.$emit('expand', args);
    },

    // 选择
    onSelect: function onSelect(args) {
      var curK = args.key;
      this.vSelectedKeys = args.selectedKeys;
      var rel = this.$props.rel;
      var listData = this.listData;
      // const selectKs = Array.isArray(args.selectedKeys) ? args.selectedKeys : [args.selectedKeys]

      var item = listData.find(function (it) {
        var k = (0, _utils.relationHandler)(rel[0], it);
        return curK === k;
      });
      var items = listData.map(function (it) {
        var k = (0, _utils.relationHandler)(rel[0], it);
        return args.selectedKeys.includes(k) ? it : null;
      }).filter(function (T) {
        return T;
      });
      this.$emit('select', args, (0, _extend2['default'])(true, {}, item || {}), (0, _extend2['default'])(true, [], items || []));
    },

    // 在多选时有效
    // 反选
    onDeselect: function onDeselect(args) {
      this.vSelectedKeys = args.selectedKeys;
      this.$emit('select', args);
    },
    onCheckChange: function onCheckChange(_ref4) {
      var checkedKeys = _ref4.checkedKeys,
          checked = _ref4.checked,
          checkedNodes = _ref4.checkedNodes,
          event = _ref4.event,
          nativeEvent = _ref4.nativeEvent,
          node = _ref4.node;
      var rel = this.$props.rel;
      var listData = this.listData;
      var dataRef = node.dataRef;
      /**
       * 获取当前选中的 key
       */

      var curSelectKey = (0, _utils.relationHandler)(rel[0], dataRef);

      var item = listData.find(function (it) {
        var k = (0, _utils.relationHandler)(rel[0], it);
        return curSelectKey === k;
      });

      var items = listData.map(function (it) {
        var k = (0, _utils.relationHandler)(rel[0], it);
        return checkedKeys.includes(k) ? it : null;
      }).filter(function (T) {
        return T;
      });

      this.$emit('check', { checkedKeys: checkedKeys, checked: checked, checkedNodes: checkedNodes, event: event, nativeEvent: nativeEvent, node: node }, (0, _extend2['default'])(true, {}, item || {}), (0, _extend2['default'])(true, [], items || []));
    },
    onUpdateCheckChange: function onUpdateCheckChange(checkedKeys) {
      this.vCheckedKeys = checkedKeys;
    },


    /**
     * 获取查询参数
     * 查询参数包括
     * 维度 dimensionId
     * 日期 queryDate
     *
     * 组装成对象
     *
     * 暂时来看查询根节点数据不需要传递其他参数
     * 也就是 查询根数据时不会有 eventKey 出现
     * @param {vNode} treeNode
     */
    getRequestParams: function getRequestParams() {
      var treeNode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var isSub = arguments[1];
      var dataRef = treeNode.dataRef,
          eventKey = treeNode.eventKey;
      var _$props4 = this.$props,
          componentType = _$props4.componentType,
          requestParam = _$props4.requestParam,
          dateOptions = _$props4.dateOptions,
          dimensionOptions = _$props4.dimensionOptions,
          searchOptions = _$props4.searchOptions;
      var dimensionValue = this.dimensionValue,
          vDateVal = this.vDateVal,
          vDateUnix = this.vDateUnix;

      var requestData = {};

      if (componentType === 'tree') {
        if (dateOptions) {
          // 时间戳
          requestData.queryDate = vDateUnix;
        }
        if (dimensionOptions) {
          requestData.dimensionId = dimensionValue;
        }
      }
      if (isSub) {
        return requestData;
      }
      requestData = (0, _extend2['default'])((0, _extends3['default'])({}, requestData), requestParam.data);

      return requestData;
    },
    setTreeData: function setTreeData() {
      var _this2 = this;

      var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
      var prentId = arguments[1];

      var map = {};
      var arrData = data.map(function (it) {
        return _this2.setTreeItemData(it, prentId);
      });

      // this.$options.noResponseData = {
      //   ...this.$options.noResponseData,
      //   ...map,
      // };

      return arrData;
    },
    setTreeItemData: function setTreeItemData(item, prentId) {
      var _mp;

      var _$props5 = this.$props,
          rel = _$props5.rel,
          renderKey = _$props5.renderKey;

      var map = {};
      var _item$data = item.data,
          loadable = _item$data.loadable,
          hasCheckbox = _item$data.hasCheckbox,
          selectable = _item$data.selectable,
          disabled = _item$data.disabled,
          data = _item$data.data;
      // 获取关键信息

      var vPid = prentId || (0, _utils.relationHandler)(rel[1], item);
      var id = (0, _utils.relationHandler)(rel[0], item);
      var name = (0, _utils.relationHandler)(renderKey, item);

      // 缓存
      map[id] = item;

      // 简化数据
      var obj = {
        // 叶子节点
        isLeaf: loadable === undefined ? false : !loadable,
        // 允许选中
        selectable: selectable,
        disabled: disabled,
        // 复选框
        // 官方文档没有 treeNode checkable 的说明, 实际是支持 `checkable` 属性的
        checkable: hasCheckbox
      };

      var key = rel[0];
      var pid = rel[1];

      // 简化数据, 从元数据中读取数据, 并重新组装
      var mp = (_mp = {}, (0, _defineProperty3['default'])(_mp, name, renderKey), (0, _defineProperty3['default'])(_mp, id, key), (0, _defineProperty3['default'])(_mp, '-1', pid), _mp);
      if (vPid) {
        mp[vPid] = pid;
        delete mp['-1'];
      }
      Object.keys(mp).map(function (k) {
        obj = (0, _extends3['default'])({}, (0, _utils.relationSetHandler)(mp[k], k, obj));
      });

      return (0, _extend2['default'])(true, {}, item, obj);
    },

    /**
     * 异步加载子节点
     * @param {当前选择的节点} treeNode;
     */
    getCategoryItemChildren: function getCategoryItemChildren(treeNode) {
      var _this3 = this;

      var _$props6 = this.$props,
          isAsyncLoad = _$props6.isAsyncLoad,
          requestSubParam = _$props6.requestSubParam,
          rel = _$props6.rel,
          renderKey = _$props6.renderKey;

      /**
       * reqData 外部传进来的对象
       */
      // const { data: reqData = {} } = requestSubParam;

      return new Promise(function (resolve) {
        var _reqKeys;

        /**
         * 不需要异步加载
         */
        if (!isAsyncLoad) {
          resolve();
          return;
        }

        var dataRef = treeNode.dataRef,
            eventKey = treeNode.eventKey;
        var _$options = _this3.$options,
            loadedCache = _$options.loadedCache,
            noResponseData = _$options.noResponseData;


        var findItem = _this3.listData.find(function (it) {
          var k = (0, _utils.relationHandler)(rel[0], it);

          return eventKey === k;
        });

        /**
         * 通过缓存判断是否需要查询
         * 这种方式比较稳妥
         */
        if (loadedCache[eventKey]) {
          /**
           * 保持与真实请求格式一致
           */
          return resolve({
            data: {
              code: 200,
              data: noResponseData[eventKey]
            }
          });
        }

        /**
         * 缓存, 不需要响应的数据
         */
        var noResponseDataCur = noResponseData[eventKey] || {};

        // if (noResponseData) {
        //   delete noResponseData.property;
        //   delete noResponseData.children;
        // }
        /**
         * 返回个带 rel[0] 指定层次的 key
         */
        // const req = relationSetHandler(rel[0], eventKey, {});
        /**
         * 取出几个关键 key, 用于请求数据
         */
        var reqKeys = (_reqKeys = {}, (0, _defineProperty3['default'])(_reqKeys, (0, _utils.relationGetKeyName)(rel[0]), (0, _utils.relationHandler)(rel[0], findItem)), (0, _defineProperty3['default'])(_reqKeys, (0, _utils.relationGetKeyName)(rel[1]), (0, _utils.relationHandler)(rel[1], findItem)), _reqKeys);
        // console.log(reqKeys);
        // const requestData = {
        //   ...requestSubParam,
        //   data: {
        //     /**
        //      * 有些接口需要的字段都不明确, 只能都穿出去
        //      */
        //     ...(findItem ? findItem.data : {}),
        //     ...reqKeys,
        //     ...this.getRequestParams(treeNode),
        //     ...reqData,
        //     // ...req.data,
        //   },
        // };
        /* 
          20210-04-25
          当前需求: 查询子节点时不需要携带 requestParam 的内容, 其中包含了维度 日期等属性
          只需携带 requestSubParam
          疑惑: *** 下边代码调用了 getRequestParams, 其中携带了 requestParam
          不知道基于什么原因, 在此记录下当前不明确的问题, 便于后续有问题时排查
           当前解决方式: 
             给 this.getRequestParams 方法 第二个参数, 判断是否子节点
             如果是查询子节点的话, 不需要合并 requestParam.data 的内容
         */
        var requestData = (0, _extend2['default'])(true, requestSubParam, {
          data: (0, _extends3['default'])({}, findItem ? findItem.data : {}, reqKeys, _this3.getRequestParams(treeNode, true))
        });

        return _this3.getTreeSub(requestData).then(function (res) {
          var resData = res.data;
          var code = resData.code,
              msg = resData.msg,
              data = resData.data;

          if (code !== 200) return Promise.reject(msg);

          _this3.$options.loadedCache[eventKey] = true;
          _this3.$options.noResponseData[eventKey] = data;

          var oldList = (0, _utils.treeToList)(_this3.treeData);
          var arrData = _this3.setTreeData(data, eventKey);
          // const newList = oldList.concat(this.setTreeData(data, eventKey));

          var tmp = [].concat((0, _toConsumableArray3['default'])(_this3.listData), (0, _toConsumableArray3['default'])(arrData));

          var _uniq = (0, _utils2.uniq)(tmp, rel[0]),
              list = _uniq.list;

          // 下边两步缺一不可


          treeNode.dataRef.children = [].concat((0, _toConsumableArray3['default'])(data));
          _this3.listData = [].concat((0, _toConsumableArray3['default'])(list));
          resolve(res);
          if (_this3.init) {
            _this3.init = false;
            _this3.$nextTick(function () {
              _this3.$emit('initialSubLoaded', {
                dimension: _this3.dimensionValue,
                date: _this3.vDateUnix,
                treeData: (0, _extend2['default'])(true, [], _this3.listData)
              });
            });
          }

          return res;
        })['catch'](function (e) {
          console.error(e);
          _this3.$message.error(e);
          return Promise.reject(e);
        });
      });
    },
    renderTree: function renderTree() {
      var _this4 = this;

      var h = this.$createElement;
      var treeData = this.treeData,
          vOpenKeys = this.vOpenKeys,
          vSelectedKeys = this.vSelectedKeys,
          vLoadData = this.vLoadData,
          vCheckedKeys = this.vCheckedKeys,
          $listeners = this.$listeners,
          $scopedSlots = this.$scopedSlots,
          $slots = this.$slots,
          filterValue = this.filterValue;
      var _$props7 = this.$props,
          componentType = _$props7.componentType,
          type = _$props7.type,
          width = _$props7.width,
          defaultOpenKeys = _$props7.defaultOpenKeys,
          defaultSelectedKeys = _$props7.defaultSelectedKeys,
          checkable = _$props7.checkable,
          checkStrictly = _$props7.checkStrictly,
          disabled = _$props7.disabled,
          draggable = _$props7.draggable,
          rel = _$props7.rel,
          multiple = _$props7.multiple,
          renderKey = _$props7.renderKey,
          treeFilter = _$props7.treeFilter;
      // const treeData = this.toTree();
      // const rootNode = treeData[0];
      // var defOpenk = vOpenKeys; //rootNode ? [rootNode[rel[0]]] : vOpenKeys;

      var eventObj = {
        select: this.onSelect,
        expand: this.onExpand,
        openChange: this.onExpand,
        'update:openKeys': this.updateOpenKeys
      };

      var treeOnly = {
        loadData: vLoadData,
        checkStrictly: checkStrictly,
        checkable: checkable,
        disabled: disabled,
        draggable: draggable,
        filterValue: filterValue,
        treeFilter: treeFilter
      };

      if (componentType === 'tree') {
        delete eventObj.openChange;
      } else {
        if (multiple) {
          eventObj.deselect = this.onDeselect;
        }
        delete eventObj.expand;
      }

      var propsObj = {
        props: {
          componentType: componentType,
          type: type,
          defaultOpenKeys: defaultOpenKeys,
          defaultSelectedKeys: defaultSelectedKeys,
          dataSource: treeData,
          width: width,
          multiple: multiple,
          selectedKeys: vSelectedKeys,
          openKeys: vOpenKeys,
          renderKey: renderKey,
          rel: rel
        },
        on: (0, _extends3['default'])({}, $listeners, eventObj),
        ref: 'swTree'
      };

      if ((0, _propsUtil.hasProp)(this, 'openKeys')) {
        delete propsObj.props.defaultOpenKeys;
      }

      if ((0, _propsUtil.hasProp)(this, 'selectedKeys')) {
        delete propsObj.props.defaultSelectedKeys;
      }

      if (componentType === 'tree') {
        propsObj.props = (0, _extends3['default'])({}, propsObj.props, treeOnly);

        if (checkable) {
          propsObj.props.checkedKeys = vCheckedKeys;
        }

        propsObj.on = (0, _extends3['default'])({}, propsObj.on, {
          'update:checkedKeys': this.onUpdateCheckChange,
          check: this.onCheckChange,
          dragenter: this.onDragenter,
          drop: this.onDrop,
          dragstart: function dragstart(o) {
            _this4.$options.vOpenKeysCache = _this4.vOpenKeys;
            _this4.$emit('dragstart', o);
          },
          dragend: function dragend(o) {
            _this4.vOpenKeys = [].concat((0, _toConsumableArray3['default'])(_this4.$options.vOpenKeysCache));
            _this4.$options.vOpenKeysCache = [];
            _this4.$emit('dragend', o);
          }
        });
        if (treeFilter) {
          propsObj.scopedSlots = (0, _extends3['default'])({}, $scopedSlots);
        }
      }
      return h(_dSwitchTree2['default'], propsObj);
    },

    /**
     * 渲染日期
     * 根据是否传入 prop 来判断是否显示
     * 日期默认值为当前日期
     * 日期变化, 查询 tree 数据
     */
    renderDate: function renderDate() {
      var _this5 = this;

      var h = this.$createElement;
      var dateOptions = this.$props.dateOptions;

      if (!dateOptions) return null;
      var dateOps = (0, _extend2['default'])(true, {}, _defaultProps.dateDefault, dateOptions);
      var type = dateOps.type,
          value = dateOps.value,
          _dateOps$props = dateOps.props,
          props = _dateOps$props === undefined ? {} : _dateOps$props;
      var vDateVal = this.vDateVal,
          dataPickerOpen = this.dataPickerOpen,
          format = this.format,
          dateDisabled = this.dateDisabled;
      // const isRangePicker = type === 'rangePicker';
      // const isNow = value === 'now';

      var dateProps = {
        props: (0, _extends3['default'])({
          open: dataPickerOpen,
          format: format,
          value: vDateVal,
          defaultValue: vDateVal
        }, props, {
          allowClear: false,
          disabled: dateDisabled
        }),
        'class': 'margin-bottom-xs',
        on: {
          change: function change(date, dateString) {
            var isClear = date === null && dateString === '';
            if (_moment2['default'].isMoment(date)) {
              _this5.vDateUnix = date.valueOf();
            } else if (isClear) {
              _this5.vDateUnix = nowDate.valueOf();
            }

            _this5.vDateVal = isClear ? nowDate : date;
            if (isClear) return;
            _this5.resetState();
            _this5.getTreeRoot().then(function () {
              _this5.initialEventHandler();
            });
            _this5.$emit('dateChange', { date: date, dateString: dateString });
          },
          openChange: function openChange(status) {
            _this5.dataPickerOpen = status;
          }
        }
      };
      return h(_antDesignVue.DatePicker, (0, _babelHelperVueJsxMergeProps2['default'])([dateProps, { 'class': 'margin-bottom-xs', ref: 'dataPieker' }]));
    },

    /**
     * 渲染header
     * 包括
     * 选择维度
     * 搜索
     */
    renderHeader: function renderHeader() {
      var _this6 = this;

      var h = this.$createElement;
      var _$props8 = this.$props,
          dimensionOptions = _$props8.dimensionOptions,
          searchOptions = _$props8.searchOptions,
          componentType = _$props8.componentType,
          searchSelectOptions = _$props8.searchSelectOptions,
          rel = _$props8.rel,
          renderKey = _$props8.renderKey,
          treeFilter = _$props8.treeFilter;

      if (componentType === 'menu') return null;
      if (!searchOptions && !dimensionOptions && !treeFilter) return;
      var vDateUnix = this.vDateUnix,
          dimensionDisabled = this.dimensionDisabled;


      var dOps = dimensionOptions ? (0, _extend2['default'])(true, {}, _defaultProps.dimensionDefaultOps, dimensionOptions) : null;
      var sOps = searchOptions ? (0, _extend2['default'])(true, {}, _defaultProps.searchDefaultOps, searchOptions) : null;

      var treeHeadProps = {
        props: {
          dimensionOptions: dOps,
          searchOptions: sOps,
          searchSelectOptions: searchSelectOptions,
          queryDate: vDateUnix,
          renderKey: renderKey,
          rel: rel,
          dimensionDisabled: dimensionDisabled,
          treeFilter: treeFilter
        },
        on: {
          dimensionChange: function dimensionChange(_ref5) {
            var value = _ref5.value,
                selectData = _ref5.selectData;

            _this6.dimensionValue = value;
            _this6.resetState();
            _this6.getTreeRoot().then(function () {
              _this6.initialEventHandler();
            });
            _this6.$emit('dimensionChange', { value: value, selectData: selectData });
          },
          searchSelect: function searchSelect(_ref6) {
            var key = _ref6.key,
                itemData = _ref6.itemData;

            /**
             * 在搜索结果中选中节点
             * 需要获取到所有父级节点
             * 并合并入已有的数据中
             * 查询子节点, 也需要查询日期,
             *
             * itemData : { hid, name }
             *
             */

            _this6.searchSelect(key, itemData);
          },
          search: function search(_ref7) {
            var data = _ref7.data;

            _this6.$emit('search', { data: data });
          },
          dimensionLoad: function dimensionLoad(data) {
            if (dimensionOptions) {
              _this6.dimensionData = data;
              if (dimensionOptions.defaultValue) {
                _this6.dimensionValue = dimensionOptions.defaultValue;
              } else if (data && data.length) {
                _this6.dimensionValue = data[0][dOps.keyName];
              }
              _this6.getTreeRoot().then(function () {
                _this6.initialEventHandler();
              });
              _this6.$emit('dimensionLoad', _this6.dimensionValue);
            }
          },
          treeFilter: function treeFilter(e) {
            var rel = _this6.$props.rel;
            var treeData = _this6.treeData,
                listData = _this6.listData,
                vOpenKeys = _this6.vOpenKeys;

            var value = e.target.value;
            var list = _this6.getListData();
            var getParentKey = function getParentKey(key) {
              var pts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

              var parents = pts;
              // let vPid = '';
              var findParent = list.find(function (item) {
                var vPid = (0, _utils.relationHandler)(rel[1], item);
                var vId = (0, _utils.relationHandler)(rel[0], item);
                if (vId === key) {
                  parents.push(vId);
                  return item;
                }
              });

              if (findParent) {
                var pid = (0, _utils.relationHandler)(rel[1], findParent);
                getParentKey(pid, parents);
              }

              return parents;
            };
            var arr = list.map(function (item) {
              var id = (0, _utils.relationHandler)(rel[0], item);
              var pid = (0, _utils.relationHandler)(rel[1], item);
              var title = (0, _utils.relationHandler)(renderKey, item);
              if (title.indexOf(value) > -1) {
                var ids = pid ? getParentKey(pid) : [id];
                return ids;
              }
              return null;
            }).filter(function (T) {
              return T;
            });

            var expandedKeys = [];
            arr.map(function (item) {
              if (Array.isArray(item)) {
                item.map(function (it) {
                  expandedKeys.push(it);
                });
              } else {
                expandedKeys.push(item);
              }
            });
            expandedKeys = [].concat((0, _toConsumableArray3['default'])(new Set([].concat((0, _toConsumableArray3['default'])(expandedKeys), (0, _toConsumableArray3['default'])(vOpenKeys)))));
            (0, _extends3['default'])(_this6, {
              vOpenKeys: [].concat((0, _toConsumableArray3['default'])(expandedKeys)),
              filterValue: value
            });

            _this6.$emit('onSyncFilterValue', value);
          }
        }
      };
      return h(_treeHeader2['default'], treeHeadProps);
    },
    initialEventHandler: function initialEventHandler() {
      this.$emit('initialEvent', {
        dimension: this.dimensionValue,
        date: this.vDateUnix,
        treeData: (0, _extend2['default'])(true, [], this.listData)
      });
    },
    resetOptions: function resetOptions() {
      this.$options.loadedCache = {};
      this.$options.noResponseData = {};
      this.$options.vOpenKeysCache = [];
    },

    /**
     * 重置状态, 与缓存
     * 切换日期, 与维度, 重置根数据, 与缓存, 包括 选中项与展开项
     */
    resetState: function resetState() {
      this.resetOptions();
      this.vSelectedKeys = [];
      this.vOpenKeys = [];
      this.vCheckedKeys = [];
      this.listData = [];
      this.init = true;
    },
    resetAllData: function resetAllData() {
      var _this7 = this;

      this.resetState();
      this.getTreeRoot().then(function () {
        _this7.initialEventHandler();
      });
    },
    getAllState: function getAllState() {
      return {
        dimension: this.dimensionValue,
        date: this.vDateUnix,
        treeData: this.listData
      };
    },
    reloadTreeData: function reloadTreeData() {
      this.resetAllData();
    },
    closeDatePickerModal: function closeDatePickerModal() {},

    /**
     * 设置 维度, 日期启用禁用
     * controlName date dimension
     */
    setDisable: function setDisable(controlName, isDisable) {
      this[controlName + 'Disabled'] = isDisable;
    }
  },

  render: function render() {
    var h = arguments[0];
    var treeData = this.treeData;
    var prefixCls = this.$props.prefixCls;


    var treeRootProps = {
      'class': (0, _classnames2['default'])((0, _defineProperty3['default'])({}, prefixCls, 1)),
      props: {
        grow: true
      }
    };
    return h(
      Vertical,
      treeRootProps,
      [this.renderDate(), this.renderHeader(), treeData && treeData.length ? this.renderTree() : null]
    );
  }
};

BTree.install = function (Vue) {
  Vue.component(BTree.name, BTree);
};

exports['default'] = BTree;
exports.defaultProps = _defaultProps2['default'];