vue-ant-patterns/biz-es/b-tree/action.js

vue-ant-patterns

import _toConsumableArray from 'babel-runtime/helpers/toConsumableArray';
/*
 * @Author: w.pengfei
 * @Date: 2020-09-06 12:03:59
 * @LastEditTime: 2020-09-11 14:08:56
 * @Description: ''
 * @LastEditors: w.pengfei
 */
import extend from 'extend';
import { listToTree, treeToList, isEmptyObj, relationHandler, relationSetHandler } from '../../es/_utils';

export default {
  name: 'tree-action',
  methods: {
    /**
     * 只能在原有数据基础上替换
     * TODO: 后续在改进
     * 在排序时会用到
     */
    setListSource: function setListSource(list) {
      this.listData = list;
    },

    // setTreeSource(source) {
    //   this.listData = treeToList(source);
    // },
    /**
     * 添加节点
     * 节点的 parentHid 已经缓存, 则直接把节点 push 进原有的 lisi 中
     * 否则通过 getCategoryItemChildren 加载 parentHid 对应的节点子节点数据
     */
    addDataToTree: function addDataToTree(data) {
      var _this = this;

      var rel = this.$props.rel;
      var vLoadData = this.vLoadData;
      var loadedCache = this.$options.loadedCache;

      /**
       * rel[1] 为取父节点 hid
       */

      var key = relationHandler(rel[1], data);
      var transData = this.setTreeItemData(data);
      /**
       * 已经加载过子节点
       */
      if (loadedCache[key]) {
        var isFind = this.listData.find(function (it) {
          var rKey = relationHandler(rel[0], it);
          var pKey = relationHandler(rel[0], data);
          return rKey === pKey;
        });
        /**
         * 未找到对应的节点
         */
        if (!isFind) {
          this.listData.push(transData);
        }
        /**
         * 展开节点的父级
         */
        this.vOpenKeys = [].concat(_toConsumableArray(new Set([].concat(_toConsumableArray(this.vOpenKeys), [key]))));
      } else {
        /**
         * t 为 treeNode
         */
        var t = this.$refs.swTree.$refs.insRef.$refs.tree.domTreeNodes;
        /**
         * 父级节点存在于树中
         */
        if (t && t[key]) {
          /**
           * 父节点在树中, 已经展开,  或者非异步加载直接追加数据
           *
           */
          if (this.vOpenKeys.includes(key) || !vLoadData) {
            /**
             * TODO: 后续完善
             * 这里需要对缓存做处理
             */
            this.listData.push(transData);
            this.upNodeLeaf(transData);
            return;
          }
          /**
           * 否则利用 open 展开, 同时自动加载数据
           */
          // this.vOpenKeys = [...new Set([...this.vOpenKeys, key])];
          this.getCategoryItemChildren(t[key]).then(function (res) {
            _this.upNodeLeaf(transData);
          });
        } else {
          /**
           * 父级节点还不存在树中
           * 需要通过传入的这个节点向上查找
           */
          var _key = relationHandler(rel[0], data);
          this.searchSelect(_key, data);
        }
      }
      /**
       * 更新父级 +-
       */
      // this.upNodeLeaf(transData);
    },
    updateItem: function updateItem(nodeData) {
      var listData = this.listData;

      var idx = this.getItemIndex(nodeData);
      if (typeof idx === 'number' && idx !== null) {
        var nData = extend(true, {}, listData[idx], { data: nodeData });
        // 数据需要转换
        var transData = this.setTreeItemData(nData);
        this.listData.splice(idx, 1, transData);
      }
    },
    deleteNode: function deleteNode(data) {
      var rel = this.$props.rel;
      var listData = this.listData;

      var idx = this.getItemIndex(data);
      if (typeof idx === 'number') {
        /**
         * 删除子节点, 还需要处理下父节点 loadable
         * loadable 用于判断是否叶子节点, false 为 叶子
         */

        var node = listData[idx];

        var parentNode = listData.find(function (it) {
          return relationHandler(rel[0], it) === relationHandler(rel[1], node);
        });

        this.listData.splice(idx, 1);

        this.upNodeLeaf(node);
        /**
         * 缓存删除
         */
        this.deleteCache(parentNode);
      }

      this.deleteCache(data);
    },
    upNodeLeaf: function upNodeLeaf(node) {
      var rel = this.$props.rel;
      var listData = this.listData;

      var hid = relationHandler(rel[0], node);
      var pHid = relationHandler(rel[1], node);
      var idx = void 0;
      var parent = listData.find(function (it, i) {
        if (relationHandler(rel[0], it) === pHid) {
          idx = i;
          return true;
        }
      });

      var chd = listData.map(function (it) {
        return relationHandler(rel[1], it) === pHid ? it : null;
      }).filter(function (T) {
        return T;
      });

      if (parent && chd && chd.length) {
        parent.data.loadable = true;
        parent.isLeaf = false;
      } else {
        parent.data.loadable = false;
        parent.isLeaf = true;
      }

      if (idx && parent) {
        this.listData.splice(idx, 1, parent);
      }
    },


    // updateParentProperty(node, property, value) {
    //   /**
    //    * 找到要处理的节点
    //    */
    //   // let node = this.listData[idx];
    //   /**
    //    * 找到父级
    //    */
    //   let parentNode = this.listData.find(it => {
    //     return relationHandler(rel[0], it) === relationHandler(rel[1], node);
    //   });

    //   if (parentNode) {
    //     const chd = this.listData.map(it => {
    //       return relationHandler(rel[0], it) === relationHandler(rel[1], node);
    //     });
    //     /**
    //      * 找到父级下的所有子级
    //      */
    //     if (!chd || !chd.length) {
    //       /**
    //        * 没子级了, 父级设为 叶子
    //        */
    //       parentNode.data[property] = value;
    //     }

    //     this.updateItem(parentNode);
    //   }
    // },
    deleteCache: function deleteCache(data) {
      var rel = this.$props.rel;
      var _$options = this.$options,
          loadedCache = _$options.loadedCache,
          noResponseData = _$options.noResponseData;


      var key = typeof data === 'string' ? data : relationHandler(rel[0], data);

      delete noResponseData[key];
      delete loadedCache[key];

      this.$options.noResponseData = noResponseData;
      this.$options.loadedCache = loadedCache;
    },
    addCache: function addCache() {},

    /**
     * 获取匹配节点的索引, 多数用于替换 删除时
     */
    getItemIndex: function getItemIndex(data) {
      var rel = this.$props.rel;
      var listData = this.listData;

      var idx = void 0;
      var id = data;
      var item = void 0;
      if (typeof data !== 'string') {
        id = relationHandler(rel[0], data);
      }
      item = listData.find(function (it, i) {
        if (relationHandler(rel[0], it) === id) {
          idx = i;
          return true;
        }
      });

      if (item && idx !== undefined) {
        return idx;
      }
      return null;
    },

    /**
     * 不知道外部用没用到
     */
    addItemData: function addItemData(data) {
      this.listData.push(data);
    }
  }
};