@uni-sw/u-design 2.0.4

package/es/components/UResTree/Tree/Tree.js

@@ -0,0 +1,3917 @@
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _regeneratorValues(e) { if (null != e) { var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"], r = 0; if (t) return t.call(e); if ("function" == typeof e.next) return e; if (!isNaN(e.length)) return { next: function next() { return e && r >= e.length && (e = void 0), { value: e && e[r++], done: !e }; } }; } throw new TypeError(_typeof(e) + " is not iterable"); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return _regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function () { return this; }), _regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
+function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } _regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { _regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, _regeneratorDefine2(e, r, n, t); }
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React, { Component, Fragment, createRef } from 'react';
+import PropTypes from 'prop-types';
+import UTreeLoader from "./UTreeLoader";
+import UTreeIcon from "./UTreeIcon";
+import UTreeNode from "./UTreeNode";
+import { _isIe } from "../../../globalFunc";
+import UInput from "../../UInput";
+import Checkbox from "../../UCheckBoxGroup/checkbox";
+import { CUSTOM_PREFIX } from "../../../globalVarious";
+import "./style";
+
+// 拼接类名前缀
+var treePrefix = "".concat(CUSTOM_PREFIX, "-tree");
+
+// 勾选状态
+var LOOP_CHECK_TYPE = {
+  // 无勾选状态
+  NONE: 0,
+  // 部分勾选
+  SOME: 1,
+  // 全部勾选
+  ALL: 2
+};
+var ORG_TYPE_ARR = ['1', '2', '3', '503', 1, 2, 3, 503];
+
+// 队列查询树结构
+var Queue = /*#__PURE__*/function () {
+  function Queue() {
+    _classCallCheck(this, Queue);
+    this.items = []; // 初始队列
+  }
+
+  /**
+   * 添加到队列
+   * @param {Object} item 被点击文件夹节点
+   */
+  return _createClass(Queue, [{
+    key: "enqueue",
+    value: function enqueue(item) {
+      if (item === 'refreshRoot' || item === 'search') {
+        // 当前请求
+        var nowData = this.items[0];
+        // 有请求
+        if (nowData) {
+          this.items = [];
+          this.items.push(nowData);
+          this.items.push({
+            type: item
+          });
+          return;
+        }
+        this.items = [];
+        this.items.push({
+          type: item
+        });
+      } else {
+        var nowIndex = -1;
+        // 遍历当前队列，找到队列是否有当前请求，有则拿到其位置
+        for (var i = 0; i < this.items.length; i++) {
+          if (this.items[i].type === 'refreshRoot' || this.items[i].type === 'search') {
+            continue;
+          }
+          if (item.item.id === this.items[i].item.id) {
+            nowIndex = i;
+          }
+        }
+        // 如果之前队列已有请求
+        if (nowIndex !== -1) {
+          // 如果传入的是当前队列真正的请求，直接返回不处理
+          if (nowIndex === 0) {
+            return;
+          }
+          // 否则将其在队列中删除
+          this.items.splice(nowIndex, 1);
+        }
+        //在队列第一个请求后加入该请求
+        this.items.splice(1, 0, item);
+      }
+      // 当前节点在队列的位置，-1表示队列没有
+    }
+
+    /**
+     * 请求完毕，删除队列第一项请求
+     */
+  }, {
+    key: "dequeue",
+    value: function dequeue() {
+      this.items.shift();
+    }
+
+    /**
+     * 判断队列是否已经存在
+     * @param {String} id 请求id
+     */
+  }, {
+    key: "isAlready",
+    value: function isAlready(id) {
+      for (var i = 0; i < this.items.length; i++) {
+        if (this.items[i].type === 'refreshRoot' || this.items[i].type === 'search') {
+          if (this.items[i].type === id) {
+            return true;
+          }
+          continue;
+        }
+        // 找到后更改index
+        if (this.items[i].item.id === id) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    /**
+     * 更新请求index值，添加正在加载节点专用
+     * @param {Number} num 当前请求的index
+     * @param {Number} num 需要变化的值
+     */
+  }, {
+    key: "upQueueIndex",
+    value: function upQueueIndex(index, num) {
+      for (var i = 0; i < this.items.length; i++) {
+        if (this.items[i].type === 'refreshRoot' || this.items[i].type === 'search') {
+          continue;
+        }
+        if (this.items[i].index > index) {
+          this.items[i].index += num;
+        }
+      }
+    }
+    /**
+     * 更新队列请求index值，请求到数据专用
+     * @param {Number} num 需要变化的值
+     */
+  }, {
+    key: "upIndex",
+    value: function upIndex(num) {
+      // 遍历当前请求，在当前请求后的index需要加上请求到的列表数量
+      for (var i = 0; i < this.items.length; i++) {
+        if (this.items[i].type === 'refreshRoot' || this.items[i].type === 'search') {
+          continue;
+        }
+        if (this.items[i].index > this.items[0].index) {
+          this.items[i].index += num;
+        }
+      }
+    }
+
+    /**
+     * 更新队列请求index值，请求到更多数据专用
+     * @param {Number} num 需要变化的值
+     */
+  }, {
+    key: "upIndeLoadMore",
+    value: function upIndeLoadMore(num) {
+      for (var i = 1; i < this.items.length; i++) {
+        if (this.items[i].type === 'refreshRoot' || this.items[i].type === 'search') {
+          continue;
+        }
+        if (this.items[i].index >= this.items[0].index) {
+          this.items[i].index += num;
+        }
+      }
+    }
+
+    /**
+     * 更新关闭其他文件夹时当前队列里组织的index值
+     * @param {Number} index 关闭文件夹的位置
+     * @param {Number} num 需要变化的值
+     */
+  }, {
+    key: "upCloseIndex",
+    value: function upCloseIndex(index, num) {
+      // 遍历当前请求，在当前请求后的index需要加上请求到的列表数量
+      for (var i = 0; i < this.items.length; i++) {
+        if (this.items[i].type === 'refreshRoot' || this.items[i].type === 'search') {
+          continue;
+        }
+        // 在当前操作的节点后面的文件夹位置都减去关闭后减少的数量
+        if (this.items[i].index > index) {
+          this.items[i].index -= num;
+        }
+      }
+    }
+
+    /**
+     * 更新打开其他文件夹时当前队列里组织的index值
+     * @param {Number} index 打开文件夹的位置
+     * @param {Number} num 需要变化的值
+     */
+  }, {
+    key: "upOpenIndex",
+    value: function upOpenIndex(index, num) {
+      // 遍历当前请求，在当前请求后的index需要加上请求到的列表数量
+      for (var i = 0; i < this.items.length; i++) {
+        if (this.items[i].type === 'refreshRoot' || this.items[i].type === 'search') {
+          continue;
+        }
+        // 在当前操作的节点后面的文件夹位置都加上打开后新增的数量
+        if (this.items[i].index > index) {
+          this.items[i].index += num;
+        }
+      }
+    }
+
+    /**
+     * 根据index判断当前请求到的数据是否要展示
+     * @param {String} bgIndex 需要隐藏任务的index范围开始值
+     * @param {String} endIndex 需要隐藏任务的index范围结束值
+     */
+  }, {
+    key: "needHide",
+    value: function needHide(bgIndex, endIndex) {
+      // 遍历当前请求，找到需要更改的任务
+      for (var i = 0; i < this.items.length; i++) {
+        if (this.items[i].type === 'refreshRoot' || this.items[i].type === 'search') {
+          continue;
+        }
+        // 找到后更改index
+        if (this.items[i].index > bgIndex && this.items[i].index <= endIndex) {
+          this.items[i].needShow = false;
+        }
+      }
+    }
+
+    /**
+     * 根据id判断当前请求到的数据是否要展示并更新index
+     * @param {String} id 需要显示任务的id值
+     */
+  }, {
+    key: "needShow",
+    value: function needShow(id, index) {
+      // 遍历当前请求，找到需要更改的任务
+      for (var i = 0; i < this.items.length; i++) {
+        if (this.items[i].type === 'refreshRoot' || this.items[i].type === 'search') {
+          continue;
+        }
+        // 找到后更改index
+        if (this.items[i].item.id === id) {
+          this.items[i].needShow = true;
+          this.items[i].index = index;
+        }
+      }
+    }
+
+    /**
+     * 隐藏正在请求到的数据
+     */
+  }, {
+    key: "hideTask",
+    value: function hideTask() {
+      if (this.items[0]) {
+        this.items[0].hideTask = true;
+      }
+    }
+
+    /**
+     * 获取队列中等待的第一个请求
+     */
+  }, {
+    key: "front",
+    value: function front() {
+      return this.items[0];
+    }
+
+    /**
+     * 获取队列中等待的请求更新后的index
+     */
+  }, {
+    key: "frontIndex",
+    value: function frontIndex() {
+      return this.items[0].index;
+    }
+
+    /**
+     * 判断队列是否为空
+     */
+  }, {
+    key: "isEmpty",
+    get: function get() {
+      return !this.items.length;
+    }
+  }]);
+}(); // 树控件只支持同时进行一个查询，如果此时在进行其他操作，都不会生效（组织节点点击、搜索、刷新）
+// 根节点加载时，会把所有数据加载完成
+// 组织节点加载时，先加载200，如果大于200，在尾部出现按钮 加载更多...
+// 树勾选功能loopCheck字段说明： 0 表示不需要；1 表示不完全勾选，出现半选样式；2 表示完全勾选，保证后渲染出来的节点也是勾选情况
+// TODO 组织节点双击之后，如果正在查询中，先出现‘正在加载’，加入等待队列中
+// TODO 搜索操作时，如果正在查询中，保持最后一个搜索（前几个搜索不生效）
+// TODO 如果有组织等待队列时，搜索了，清空组织等待队列
+var Tree = /*#__PURE__*/function (_Component) {
+  function Tree(props) {
+    var _this;
+    _classCallCheck(this, Tree);
+    _this = _callSuper(this, Tree, [props]);
+    /**
+     * 点击上滚动条
+     */
+    _this._scrollTop = function () {
+      var e = {
+        nativeEvent: {
+          wheelDelta: 120
+        }
+      };
+      _this._commonwheel(e);
+    };
+    /**
+     * 点击下滚动条
+     */
+    _this._scrollBottom = function () {
+      var e = {
+        nativeEvent: {
+          wheelDelta: -120
+        }
+      };
+      _this._commonwheel(e);
+    };
+    /**
+     * 刷新父节点
+     * @param {Boolean} parentId 需要刷新父节点的id
+     * @param {String} resId 刷新后需要高亮选中的resId
+     */
+    _this.refreshPrentNode = function (parentId, resId) {
+      if (parentId === _this.initRootNodeId || parentId === 'root') {
+        if (resId) {
+          _this.refreshRootNode(resId);
+        } else {
+          _this.refreshRootNode();
+        }
+      } else {
+        var index = -1;
+        var item = {};
+        for (var i = 0; i < _this.cameraArray.length; i++) {
+          var element = _this.cameraArray[i];
+          if (parentId === element.id) {
+            index = i;
+            item = element;
+          }
+        }
+        if (!_this.dataObj[item.parentId] || index === -1) {
+          if (resId) {
+            _this.refreshRootNode(resId);
+          } else {
+            _this.refreshRootNode();
+          }
+          return;
+        }
+        var temp = _this.dataObj[item.parentId];
+        if (resId) {
+          _this.refreshNormalNode(item.id, item.resId, index, temp.floor, resId);
+        } else {
+          _this.refreshNormalNode(item.id, item.resId, index, temp.floor);
+        }
+      }
+    };
+    /**
+     * 鼠标移入移出事件
+     * @param {string} eventType 移入/移出 
+     * @param {object} item 被点击节点对象
+     */
+    _this._mouseEvent = function (eventType, item) {
+      _this.setState({
+        mouseEnterNode: eventType === 'mouseEnter' ? item.id : ''
+      });
+    };
+    /**
+     * 计算左右滚动条是否需要显示
+     */
+    _this._leftDistance = function () {
+      // const { isNeedSearch } = this.props;
+      // let searchHeight = isNeedSearch ? '50px' : '0px'; // 搜索框的高度
+      // 如果存在组织
+      if (_this.refs.treeBoxUl.getElementsByClassName("".concat(treePrefix, "-icon")).length > 0) {
+        _this.leftDistance = 0;
+        // 获取所有图标
+        var allTitle = _this.refs.treeBoxUl.getElementsByClassName("".concat(treePrefix, "-node-desc"));
+        for (var i = 0; i < allTitle.length; i++) {
+          var maxLeft = allTitle[i].clientWidth + allTitle[i].getBoundingClientRect().left;
+          if (maxLeft > _this.leftDistance) {
+            // 取到最大的需要看见的位置离左侧的位置
+            _this.leftDistance = maxLeft;
+          }
+        }
+        // 左右可以滚动的距离
+        var scrollBarLeft = _this.refs.scrollbar ? _this.refs.scrollbar.clientWidth + 5 : 5;
+        var canscroll = _this.leftDistance - (_this.refs.treeBoxUl.getBoundingClientRect().left + _this.treeBoxUlWidth) + scrollBarLeft;
+        if (canscroll >= 0) {
+          _this.treeUlBoxLeftCanDistamce = canscroll;
+          if (_this.refs.leftScrollBall) {
+            _this.refs.leftScrollBall.style.width = "".concat(_this.treeBoxUlWidth / (_this.treeBoxUlWidth + canscroll) * _this.leftScrollBoxWidth, "px");
+            _this.leftScrollBallWidth = _this.refs.leftScrollBall.clientWidth;
+          }
+          _this.needLeftScroll = true;
+          _this.refs.treeMain.style.paddingBottom = '15px';
+          // this.refs.treeMain.style.height = `calc(100% - ${searchHeight} + 15px)`;
+          if (_this.refs.leftScrollBox) {
+            _this.refs.leftScrollBox.style.opacity = 1;
+          }
+        } else if (canscroll < 0) {
+          _this.refs.treeMain.style.paddingBottom = '0px';
+          // this.refs.treeMain.style.height = `calc(100% - ${searchHeight})`;
+          _this.needLeftScroll = false;
+          _this._recoverLeftScroll();
+        }
+      }
+    };
+    /**
+     * 左右滚动条被按下
+     */
+    _this._leftScrollDown = function (e) {
+      _this.leftScrollDownPos = e.pageX;
+      e.preventDefault();
+      document.addEventListener('mousemove', _this._leftScrollMove);
+      document.addEventListener('mouseup', _this._leftScrollUp);
+      if (window.self !== window.top && window.parent) {
+        document.addEventListener('mouseleave', _this._leftScrollLeave);
+      }
+    };
+    /**
+     * 左右滚动条正在移动
+     */
+    _this._leftScrollMove = function (e) {
+      // 当前滚动条移动的距离
+      var distance = _this.leftScrollPos + (e.pageX - _this.leftScrollDownPos);
+      // 如果移到最左边
+      if (distance <= 0) {
+        distance = 0;
+      }
+      // 如果移到最右边
+      if (distance >= _this.leftScrollBoxWidth - _this.leftScrollBallWidth) {
+        distance = _this.leftScrollBoxWidth - _this.leftScrollBallWidth;
+      }
+      // 左右滚动条移动的占比
+      var leftScrollpProp = distance / (_this.leftScrollBoxWidth - _this.leftScrollBallWidth);
+      _this.treeUlBoxLeftPos = leftScrollpProp * _this.treeUlBoxLeftCanDistamce;
+      // 设置树组织滚动
+      _this.refs.leftScrollBall.style.transform = "translateX(".concat(distance, "px)");
+      _this.refs.treeBoxUl.style.width = "".concat(_this.treeBoxUlWidth + _this.treeUlBoxLeftPos, "px");
+      _this.refs.treeBoxUl.style.transform = "translateX(-".concat(_this.treeUlBoxLeftPos, "px)");
+    };
+    /**
+     * 左右滚动条移动结束
+     */
+    _this._leftScrollUp = function (e, needScroll) {
+      // 当前滚动条移动的距离
+      var distance = 0;
+      if (needScroll) {
+        distance = _this.leftScrollPos + needScroll;
+      } else {
+        distance = _this.leftScrollPos + (e.pageX - _this.leftScrollDownPos);
+      }
+      // 如果移到最左边
+      if (distance <= 0) {
+        distance = 0;
+      }
+      // 如果移到最右边
+      if (distance >= _this.leftScrollBoxWidth - _this.leftScrollBallWidth) {
+        distance = _this.leftScrollBoxWidth - _this.leftScrollBallWidth;
+      }
+      // 设置树组织滚动
+      // 得到当前左右滚动条位置占比
+      var leftScrollpProp = distance / (_this.leftScrollBoxWidth - _this.leftScrollBallWidth);
+      _this.treeUlBoxLeftPos = leftScrollpProp * _this.treeUlBoxLeftCanDistamce;
+      // 设置树组织滚动
+      _this.refs.leftScrollBall.style.transform = "translateX(".concat(distance, "px)");
+      _this.refs.treeBoxUl.style.width = "".concat(_this.treeBoxUlWidth + _this.treeUlBoxLeftPos, "px");
+      _this.refs.treeBoxUl.style.transform = "translateX(-".concat(_this.treeUlBoxLeftPos, "px)");
+      _this.leftScrollPos = distance;
+      document.removeEventListener('mousemove', _this._leftScrollMove);
+      document.removeEventListener('mouseup', _this._leftScrollUp);
+      document.removeEventListener('mouseleave', _this._leftScrollLeave);
+    };
+    /**
+     * 在iframe里要监听移除文档事件
+     */
+    _this._leftScrollLeave = function (e) {
+      _this._leftScrollUp(e);
+      document.removeEventListener('mousemove', _this._leftScrollMove);
+      document.removeEventListener('mouseup', _this._leftScrollUp);
+      document.removeEventListener('mouseleave', _this._leftScrollLeave);
+    };
+    /**
+     * 点击左滚动
+     */
+    _this._leftScrollLeft = function () {
+      _this._leftScrollUp(true, -10);
+    };
+    /**
+     * 点击右滚动
+     */
+    _this._leftScrollRight = function () {
+      _this._leftScrollUp(true, 10);
+    };
+    /**
+     * 重置滚动条位置
+     */
+    _this._recoverLeftScroll = function () {
+      // 如果有滚动条
+      if (_this.refs.leftScrollBall) {
+        _this.leftScrollBoxWidth = _this.refs.leftScrollBox.clientWidth;
+        _this.leftScrollPos = 0;
+        _this.refs.leftScrollBall.style.transform = 'none';
+        _this.refs.treeBoxUl.style.width = '100%';
+        _this.refs.treeBoxUl.style.transform = 'none';
+      }
+    };
+    _this.state = {
+      //树可视最大容纳数
+      eachNum: 2,
+      //数组结束号数
+      endSum: 2,
+      //数组开始号数
+      beginSum: 0,
+      //滚动条是否需要显示
+      isScrollbarShow: false,
+      //input的value值
+      value: '',
+      // 滚动条的height
+      scrollbarHeight: 0,
+      // 滚动条的top
+      scrollbarTop: 0,
+      // 正在加载否
+      isLoading: false,
+      // 最后一个节点是否需要省略号
+      isLastNodeNeedEllipsis: false
+    };
+    // 储存请求获取的数据
+    _this.dataObj = {
+      root: {
+        data: [],
+        floor: 1
+      }
+    };
+    // 单个树节点高度
+    _this.perHeight = 30;
+    // 打开关闭文件夹标记数组
+    _this.openTagArr = [];
+    //文件夹数组
+    _this.floderArr = [];
+    //遍历用的数组
+    _this.cameraArray = [];
+    //滚动条距离上部高度
+    _this.scrollbarTop = 0;
+    //树的总高
+    _this.treeTotalHeight = 0;
+    //递归时暂存数组
+    _this.recursionArr = [];
+    //根节点是否展开
+    _this.isTreeRootExpand = true;
+    //需要初始加载的根节点id
+    _this.initRootNodeId = '';
+    //请求单通道
+    _this.channel = true;
+    // 是否有请求开始函数
+    _this.hasRequestStart = false;
+    // 是否有请求结束函数
+    _this.hasRequestFinish = false;
+    // 判断是否在搜索
+    _this.isSearching = false;
+    // 正在加载提示语
+    _this.loadingPrompt = '正在加载...'; // 正在加载...
+    // 更多加载提示语
+    _this.loadMorePrompt = '点击加载更多...'; // 点击加载更多...
+    _this.loadSearchNone = '无结果...'; // 无结果...
+    // 需要显示checkbox的类型
+    _this.showCheckboxTypes = [];
+    // 重新渲染时 0两次判断
+    _this.zeroTag = 0;
+    // ref创建
+    _this.treeBox = /*#__PURE__*/createRef();
+    // 实例化队列
+    _this.queue = new Queue();
+    // 是否正在请求数据
+    _this.isRequest = false;
+    // 新增子组织的数量
+    _this.newNodeNum = 0;
+    // 正在进行刷新子节点
+    // this.isRefreshNormal = false;
+
+    // 组织图标离左侧的距离
+    _this.leftDistance = 0;
+    // 左右滚动条可以滚动的距离
+    _this.treeUlBoxLeftCanDistamce = 0;
+    // 组织树当前的左右位置
+    _this.treeUlBoxLeftPos = 0;
+    // 组织树的宽
+    _this.treeBoxUlWidth = 0;
+    // 左右滚动条总的的宽
+    _this.leftScrollBoxWidth = 0;
+    //左右滚动条当前的宽
+    _this.leftScrollBallWidth;
+    // 左右滚动条当前被点击的位置
+    _this.leftScrollDownPos = 0;
+    // 左右滚动条当前的位置
+    _this.leftScrollPos = 0;
+    // 是否需要显示滚动条
+    _this.needLeftScroll = true;
+    // 搜索按下时的内容
+    _this.searchValue = '';
+    _this.defaultClickNode = '';
+    _this.selectNode = {};
+
+    // 上一次搜索的节点key值
+    _this.lastSearchKey = 'iccsid';
+    // 点击节点的key值
+    _this.clickOrgKey = 'iccsid';
+    _this._commonwheel = _this._commonwheel.bind(_this);
+    _this._moveScroll = _this._moveScroll.bind(_this);
+    _this._clickRoot = _this._clickRoot.bind(_this);
+    _this._down = _this._down.bind(_this);
+    _this._clickFloder = _this._clickFloder.bind(_this);
+    _this._mouseMove = _this._mouseMove.bind(_this);
+    _this._loadMore = _this._loadMore.bind(_this);
+    _this._onWindowResize = _this._onWindowResize.bind(_this);
+    _this.getChildrenNode = _this.getChildrenNode.bind(_this);
+    _this.getRootNode = _this.getRootNode.bind(_this);
+    _this.refreshRootNode = _this.refreshRootNode.bind(_this);
+    _this.refreshNormalNode = _this.refreshNormalNode.bind(_this);
+    _this._handleChange = _this._handleChange.bind(_this);
+    _this._clickSearch = _this._clickSearch.bind(_this);
+    _this._clickDelete = _this._clickDelete.bind(_this);
+    _this._getKey = _this._getKey.bind(_this);
+    _this.getIsTreeRootExpand = _this.getIsTreeRootExpand.bind(_this);
+    _this.isShowOrgInfo = false;
+    return _this;
+  }
+
+  //#region 生命周期函数
+  _inherits(Tree, _Component);
+  return _createClass(Tree, [{
+    key: "componentWillMount",
+    value: function componentWillMount() {
+      var _this$props = this.props,
+        treeIcon = _this$props.treeIcon,
+        _this$props$treeLoade = _this$props.treeLoader,
+        treeLoader = _this$props$treeLoade === void 0 ? UTreeLoader : _this$props$treeLoade,
+        treeNode = _this$props.treeNode,
+        requestFinishedFunc = _this$props.requestFinishedFunc,
+        dataTypes = _this$props.dataTypes,
+        labelTypes = _this$props.labelTypes,
+        checkboxTypes = _this$props.checkboxTypes,
+        canDragType = _this$props.canDragType,
+        defaultSelect = _this$props.defaultSelect,
+        rootNode = _this$props.rootNode,
+        intoOrOutCity = _this$props.intoOrOutCity,
+        isSGK = _this$props.isSGK,
+        IOTSubType = _this$props.IOTSubType,
+        isUseOldTree = _this$props.isUseOldTree,
+        combineThreeCode = _this$props.combineThreeCode,
+        isShowOrgInfo = _this$props.isShowOrgInfo,
+        isSlectCmaedd = _this$props.isSlectCmaedd,
+        isPartCheckInfo = _this$props.isPartCheckInfo,
+        requestFailedFunc = _this$props.requestFailedFunc;
+      // 树组件加载方式
+      this.treeLoader = new treeLoader(dataTypes, labelTypes, canDragType, defaultSelect, rootNode, intoOrOutCity, isSGK, IOTSubType, isUseOldTree, combineThreeCode, isSlectCmaedd, isShowOrgInfo, isPartCheckInfo);
+
+      // 请求完成的需调用的方法
+      this.treeLoader.init(requestFinishedFunc, requestFailedFunc);
+
+      // 树组件icon
+      this.treeIcon = new treeIcon();
+      this.treeIcon.init();
+
+      // 树节点结构对象
+      this.treeNodeObj = treeNode;
+      this.isShowOrgInfo = isShowOrgInfo;
+
+      // 设置需要显示checkbox的类型
+      if (typeof checkboxTypes === 'string' || typeof checkboxTypes === 'number') {
+        this.showCheckboxTypes.push(parseInt(checkboxTypes, 10));
+      } else if (checkboxTypes instanceof Array) {
+        this.showCheckboxTypes = checkboxTypes;
+      }
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.setState({
+        beginSum: 0,
+        eachNum: this._changeByTreeHeight()
+      });
+      this.queue.enqueue('refreshRoot');
+      this._addRoot();
+
+      //去除鼠标右键默认事件
+      document.addEventListener('contextmenu', this._preventDefault);
+      document.addEventListener('selectstart', this._selectStartF);
+      window.addEventListener('resize', this._onWindowResize);
+      this.treeBox.current.addEventListener('wheel', this._preventDefault);
+      this.treeBoxUlWidth = this.refs.treeBoxUl.clientWidth;
+      this.leftScrollBoxWidth = this.refs.leftScrollBox.clientWidth;
+      this.leftScrollBallWidth = this.refs.leftScrollBall.clientWidth;
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      this._renderRecalcNum();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      //避免组件卸载后继续setState造成的内存泄露
+      this.setState = function (state, callback) {
+        return;
+      };
+      window.removeEventListener('resize', this._onWindowResize);
+      document.removeEventListener('contextmenu', this._preventDefault);
+      document.removeEventListener('selectstart', this._selectStartF);
+      this.treeBox.current.removeEventListener('wheel', this._preventDefault);
+    }
+
+    /**
+     * 窗口大小变化 自适应
+     */
+  }, {
+    key: "_onWindowResize",
+    value: function _onWindowResize() {
+      var _this2 = this;
+      var _this$state = this.state,
+        beginSum = _this$state.beginSum,
+        endSum = _this$state.endSum,
+        isScrollbarShow = _this$state.isScrollbarShow,
+        eachNum = _this$state.eachNum;
+      //监测窗口大小改变后 获取当前高度可容纳的条数,修改可容纳数
+      eachNum = this._changeByTreeHeight();
+      var changeNum = beginSum + eachNum;
+      //当窗口变大，数量不够显示，需要调整位置
+      if (changeNum > this.cameraArray.length) {
+        beginSum = this.cameraArray.length - eachNum;
+      }
+      beginSum = beginSum < 0 ? 0 : beginSum;
+
+      // 如果节点数量大于可容纳数量，显示滚动条
+      if (this.cameraArray.length > eachNum) {
+        isScrollbarShow = true;
+        endSum = beginSum + eachNum;
+      } else {
+        isScrollbarShow = false;
+        endSum = this.cameraArray.length;
+      }
+      this.setState({
+        beginSum: beginSum,
+        endSum: endSum,
+        isScrollbarShow: isScrollbarShow,
+        eachNum: eachNum
+      }, function () {
+        if (_this2.isTreeRootExpand) {
+          _this2._moveScroll();
+        }
+      });
+    }
+
+    /**
+     * 禁止默认事件
+     */
+  }, {
+    key: "_preventDefault",
+    value: function _preventDefault(e) {
+      e.preventDefault();
+    }
+
+    /**
+     * 禁止左键选中
+     */
+  }, {
+    key: "_selectStartF",
+    value: function _selectStartF() {
+      return false;
+    }
+
+    //#endregion
+
+    //#region root相关部分代码
+
+    /**
+     * 根据当前用户，添加根节点
+     */
+  }, {
+    key: "_addRoot",
+    value: function _addRoot() {
+      var _this3 = this;
+      this._removeLoadingNode(0);
+      var _this$props2 = this.props,
+        needRootNode = _this$props2.needRootNode,
+        autoSelectBase = _this$props2.autoSelectBase;
+      // 如果不需要根节点，表示没有根节点，数据直接保存在root对象中
+      if (!needRootNode) {
+        this.initRootNodeId = 'root';
+        if (autoSelectBase) {
+          this.setState({
+            isClickNode: 'root'
+          });
+        }
+        if (this.defaultClickNode) {
+          this.setState({
+            isClickNode: this.defaultClickNode
+          });
+        }
+      } else {
+        //添加根节点
+        this.treeLoader.initRoot().then(function (result) {
+          // 请求发生错误,设置为无根节点
+          if (result === false) {
+            _this3.queue.dequeue();
+            // 当前请求不为空
+            if (!_this3.queue.isEmpty) {
+              _this3._nextQueue();
+            }
+            _this3.initRootNodeId = 'root';
+            if (autoSelectBase) {
+              _this3.setState({
+                isClickNode: 'root'
+              });
+            }
+            if (_this3.defaultClickNode) {
+              _this3.setState({
+                isClickNode: _this3.defaultClickNode
+              });
+            }
+          } else {
+            _this3._addTreeRoot(result);
+            _this3.initRootNodeId = result.id;
+            if (autoSelectBase) {
+              _this3.setState({
+                isClickNode: result.id
+              });
+            }
+            if (_this3.defaultClickNode) {
+              _this3.setState({
+                isClickNode: _this3.defaultClickNode
+              });
+            }
+            _this3.setState({
+              endSum: _this3.dataObj.root.data.length + 1
+            });
+            //添加根节点标识
+            _this3.openTagArr.push(_this3.initRootNodeId);
+            _this3.floderArr.push(_this3.initRootNodeId);
+            //默认打开根节点
+            if (_this3.isTreeRootExpand) {
+              _this3._loadRoot();
+            }
+          }
+        });
+      }
+    }
+
+    /**
+     * 添加根节点
+     * @param {*} rootNode
+     */
+  }, {
+    key: "_addTreeRoot",
+    value: function _addTreeRoot(rootNodeObj) {
+      // 当前请求的数据需要
+      if (this.queue.front().hideTask !== true) {
+        this.dataObj.root.data.push(rootNodeObj);
+        this.cameraArray.push(rootNodeObj);
+      }
+      this.dataObj[rootNodeObj.id] = {
+        data: [],
+        self: rootNodeObj,
+        floor: 2
+      };
+    }
+
+    /**
+     * 根节点首次加载
+     */
+  }, {
+    key: "_loadRoot",
+    value: function _loadRoot() {
+      var _this4 = this;
+      var resArray = this.dataObj[this.initRootNodeId];
+      var cameraArray = this.cameraArray;
+      // 加载节点的index
+      var loadingIndex = cameraArray.length;
+      // 当前请求的数据需要
+      if (this.queue.front() && this.queue.front().hideTask !== true) {
+        this._addLoadingNode(loadingIndex, resArray.floor, 'root');
+      }
+      // 加载根节点的时候，初始化搜索域节点
+      this.lastSearchKey = 'iccsid';
+      // 加载根节点的时候，初始化店家节点信息
+      this.clickOrgKey = 'iccsid';
+      this.treeLoader.setRequestObj({
+        requestType: 'root'
+      });
+
+      // 请求根节点下的数据
+      this.treeLoader.getRootNode().then(function (responseData) {
+        if (responseData === false) {
+          if (_this4.isTreeRootExpand) {
+            _this4._removeLoadingNode(loadingIndex);
+          } else {
+            _this4.cameraArray.splice(loadingIndex, 1);
+          }
+          _this4.queue.upQueueIndex(loadingIndex, -1);
+          _this4.queue.dequeue();
+          // 当前请求不为空
+          if (!_this4.queue.isEmpty) {
+            _this4._nextQueue();
+          }
+          _this4.isSearching = false;
+          return;
+        }
+        responseData = _this4.treeLoader.toTreeNode(responseData, _this4.initRootNodeId);
+        var _this4$state = _this4.state,
+          eachNum = _this4$state.eachNum,
+          endSum = _this4$state.endSum;
+        // 当前请求的数据需要
+        if (_this4.queue.front() && _this4.queue.front().hideTask !== true) {
+          // 如果父节点设置了需要勾选，那么新打开的子节点进行勾选操作
+          if (resArray.self.isCheck && _this4.props.isLoopCheck) {
+            for (var index = 0, length = responseData.length; index < length; index++) {
+              responseData[index].isCheck = true;
+              // 如果是组织节点，也添加上loopCheck
+              if (responseData[index].isOrgNode === true) {
+                responseData[index].loopCheck = LOOP_CHECK_TYPE.ALL;
+              }
+            }
+          }
+          Array.prototype.push.apply(resArray.data, responseData);
+          cameraArray.splice.apply(cameraArray, [cameraArray.length, 0].concat(_toConsumableArray(responseData)));
+          _this4.props.requestFinishdeToNodeFunc(resArray.data, _this4.dataObj);
+          _this4.props.nodeLoadFinishedFunc(responseData, _this4.dataObj);
+        }
+        if (cameraArray.length < eachNum) {
+          endSum = cameraArray.length;
+        } else {
+          endSum = eachNum;
+        }
+        _this4.setState({
+          endSum: endSum,
+          beginSum: 0
+        }, function () {
+          _this4._moveScroll();
+          _this4._continueRoot(loadingIndex);
+        });
+      }).catch(function (err) {
+        if (_this4.isTreeRootExpand) {
+          _this4._removeLoadingNode(loadingIndex);
+        } else {
+          _this4.cameraArray.splice(loadingIndex, 1);
+        }
+        _this4.queue.upQueueIndex(loadingIndex, -1);
+        _this4.queue.dequeue();
+        // 当前请求不为空
+        if (!_this4.queue.isEmpty) {
+          _this4._nextQueue();
+        }
+        _this4.isSearching = false;
+        console.error(err);
+      }).finally(function () {
+        _this4._judgeScrollbarShow();
+        _this4._moveScroll();
+        _this4.checkNode();
+      });
+    }
+
+    // 节点信息更新后更新节点状态
+  }, {
+    key: "checkNode",
+    value: function checkNode() {
+      var _this$props3 = this.props,
+        onReset = _this$props3.onReset,
+        checkResList = _this$props3.checkResList;
+      for (var key in this.dataObj) {
+        var data = this.dataObj[key];
+        // 当前组织下是否有节点被选中
+        var tempCheck = false;
+        var _loop = function _loop() {
+          var item = data.data[j];
+          if (checkResList && checkResList.length > 0) {
+            // 如果勾选了，把对应item的状态设置成checked
+            if (checkResList.some(function (res) {
+              return res.resId === item.resId;
+            }) || checkResList.some(function (res) {
+              return res.id === item.id;
+            }) || checkResList.includes(item.resId) || checkResList.includes(item.id) || checkResList.some(function (res) {
+              return typeof res === 'number' && res === item.resourceInfo.resType;
+            })) {
+              item.isCheck = true;
+              tempCheck = true;
+            }
+          }
+        };
+        for (var j = 0, dataLen = data.data.length; j < dataLen; j++) {
+          _loop();
+        }
+        // 如果有节点被选中，根据最后一个节点信息去设置其父节点选中状态
+        if (tempCheck) {
+          this._loopCheckParentItem(data.data[data.data.length - 1], true);
+        }
+      }
+      this.forceUpdate();
+      typeof onReset === 'function' && onReset();
+    }
+
+    /**
+     * 继续请求根节点
+     * @param {number} loadingIndex 加载节点的序号
+     */
+  }, {
+    key: "_continueRoot",
+    value: (function () {
+      var _continueRoot2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(loadingIndex) {
+        var _this5 = this;
+        var resArray, _this$cameraArray, continueData, itemIndex;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              resArray = this.dataObj[this.initRootNodeId];
+            case 1:
+              // 继续请求根节点数据，直到结束
+              this.treeLoader.setRequestObj({
+                requestType: 'root'
+              });
+              _context.n = 2;
+              return this.treeLoader.continueGetRootNode();
+            case 2:
+              continueData = _context.v;
+              if (continueData) {
+                _context.n = 3;
+                break;
+              }
+              return _context.a(3, 5);
+            case 3:
+              continueData = this.treeLoader.toTreeNode(continueData, this.initRootNodeId);
+              // 当前请求的数据不需要
+              if (this.queue.front().hideTask !== true) {
+                Array.prototype.push.apply(resArray.data, continueData);
+                this.props.requestFinishdeToNodeFunc(resArray.data, this.dataObj);
+              }
+              (_this$cameraArray = this.cameraArray).splice.apply(_this$cameraArray, [this.cameraArray.length, 0].concat(_toConsumableArray(continueData)));
+              this.props.nodeLoadFinishedFunc(continueData, this.dataObj);
+              this.setState({
+                eachNum: this.state.eachNum
+              }, this._moveScroll);
+            case 4:
+              _context.n = 1;
+              break;
+            case 5:
+              if (this.isTreeRootExpand) {
+                this._removeLoadingNode(loadingIndex);
+                this.queue.upQueueIndex(loadingIndex, -1);
+              } else {
+                this.cameraArray.splice(loadingIndex, 1);
+              }
+              this._judgeScrollbarShow();
+              this.queue.upQueueIndex(loadingIndex, -1);
+              this.queue.dequeue();
+              // 当前请求不为空
+              if (!this.queue.isEmpty) {
+                this._nextQueue();
+              }
+
+              // 根节点展开时，自动展开第一个组织节点
+              if (this.props.autoExpandFirstOrg) {
+                itemIndex = this.cameraArray.findIndex(function (item) {
+                  return item.parentId === _this5.initRootNodeId && item.isOrgNode;
+                });
+                if (itemIndex > -1) {
+                  this._clickFloder(this.cameraArray[itemIndex], itemIndex);
+                }
+              }
+              this.isSearching = false;
+            case 6:
+              return _context.a(2);
+          }
+        }, _callee, this);
+      }));
+      function _continueRoot(_x) {
+        return _continueRoot2.apply(this, arguments);
+      }
+      return _continueRoot;
+    }()
+    /**
+     * 根节点点击事件
+     */
+    )
+  }, {
+    key: "_clickRoot",
+    value: function _clickRoot() {
+      var _this6 = this;
+      var _this$state2 = this.state,
+        eachNum = _this$state2.eachNum,
+        beginSum = _this$state2.beginSum;
+      //根节点处于展开情况，关闭根节点
+      if (this.isTreeRootExpand) {
+        this.openTagArr.splice(this.openTagArr.indexOf(this.initRootNodeId), 1);
+        this.needLeftScroll = false;
+        this._recoverLeftScroll();
+        this.setState({
+          beginSum: 0,
+          endSum: this.dataObj.root.data.length,
+          isScrollbarShow: false
+        });
+        this.isTreeRootExpand = false;
+      } else {
+        var root = this.dataObj[this.initRootNodeId];
+        this.openTagArr.push(this.initRootNodeId);
+        //如果是第一次打开
+        if (root.data.length === 0) {
+          this._loadRoot();
+          return;
+        }
+        this.isTreeRootExpand = true;
+        this.setState({
+          beginSum: beginSum,
+          endSum: eachNum
+        }, function () {
+          _this6._judgeScrollbarShow();
+          _this6._moveScroll();
+        });
+      }
+    }
+
+    /**
+     * 根节点状态
+     */
+  }, {
+    key: "getIsTreeRootExpand",
+    value: function getIsTreeRootExpand() {
+      return this.isTreeRootExpand;
+    }
+    //#endregion
+
+    //#region 滚动条相关部分代码
+    /**
+     * 判断滚动条是否需要显示
+     */
+  }, {
+    key: "_judgeScrollbarShow",
+    value: function _judgeScrollbarShow() {
+      var eachNum = this.state.eachNum;
+      var isShow = false;
+      // 总数大于最大容纳数,显示滚动条
+      if (this.cameraArray.length > eachNum) {
+        isShow = true;
+      } else {
+        isShow = false;
+      }
+      this.setState({
+        isScrollbarShow: isShow
+      });
+    }
+
+    /**
+     * 设置滚轮的高度
+     * 根据显示的beginSum和总的树节点数，计算高度
+     */
+  }, {
+    key: "_moveScroll",
+    value: function _moveScroll() {
+      var _this$state3 = this.state,
+        eachNum = _this$state3.eachNum,
+        beginSum = _this$state3.beginSum,
+        isScrollbarShow = _this$state3.isScrollbarShow;
+      var totalNum = this.cameraArray.length;
+      // 滚轮显示情况下
+      if (isScrollbarShow) {
+        this.maxTop = (totalNum - eachNum) / totalNum * (this.treeTotalHeight - 30);
+        this.scrollbarTop = beginSum / totalNum * (this.treeTotalHeight - 30);
+        // 滚动条超出最大高度时
+        if (this.scrollbarTop > this.maxTop) {
+          this.scrollbarTop = this.maxTop;
+        } else if (this.scrollbarTop < 0) {
+          this.scrollbarTop = 0;
+        }
+        // 设置滚动条的高度和top值
+        this.setState({
+          scrollbarHeight: eachNum / totalNum * 100 + '%',
+          scrollbarTop: this.scrollbarTop + 'px'
+        });
+      } else {
+        this.forceUpdate();
+      }
+      this.isLocating = false;
+    }
+
+    /**
+     * 鼠标滚轮事件
+     * @param {*} e react event事件对象
+     */
+  }, {
+    key: "_commonwheel",
+    value: function _commonwheel(e) {
+      if (!this.isTreeRootExpand) {
+        return;
+      }
+      //chrome 滚轮wheelDelta属性 上120 下-120
+      //firefox 滚轮deltaY属性 上-3 下3
+      var wheelNum = e.nativeEvent.wheelDelta || -e.nativeEvent.deltaY;
+      var _this$state4 = this.state,
+        endSum = _this$state4.endSum,
+        beginSum = _this$state4.beginSum;
+      var dataSum = this.cameraArray.length;
+      //向下滚动  设置起始和结束各 +1
+      if (wheelNum < 0) {
+        if (endSum < dataSum) {
+          this.setState({
+            endSum: endSum + 1,
+            beginSum: beginSum + 1
+          }, this._moveScroll);
+        } else if (endSum === dataSum && this.isSearching && this.cameraArray[dataSum - 1].type === 'searchMore') {
+          // 移动到最后，且正在搜索中，最后一个节点是更多加载
+          // 执行搜索更多
+          this._continueSearching();
+        }
+      } else {
+        //向上滚动  设置起始和结束各 -1
+        if (beginSum > 0) {
+          this.setState({
+            endSum: endSum - 1,
+            beginSum: beginSum - 1
+          }, this._moveScroll);
+        }
+      }
+    }
+
+    /**
+     * 点击滚动条
+     * @param {*} e react event事件对象
+     */
+  }, {
+    key: "_down",
+    value: function _down(e) {
+      var _this7 = this;
+      //鼠标按下时的鼠标高度
+      var startY = e.nativeEvent.clientY;
+      e.preventDefault();
+      //按下时的滚动条top
+      var defaultY = this.scrollbarTop;
+      document.onmousemove = function (e) {
+        return _this7._mouseMove(e, startY, defaultY);
+      };
+      document.onmouseup = function () {
+        document.onmousemove = null;
+        document.onmouseup = null;
+      };
+      if (window.self !== window.top && window.parent) {
+        document.onmouseleave = function () {
+          document.onmousemove = null;
+          document.onmouseup = null;
+          document.onmouseleave = null;
+        };
+      }
+    }
+
+    /**
+     * 鼠标move 动态设置滚动条
+     * 根据初始位置，计算移动鼠标后的滚动条clientY，然后计算出显示数组的起始和结束位置
+     * @param {*} e react event事件对象
+     * @param {number} startY 点击滚动条时，鼠标的clientY（距可视窗口的Y轴距离）
+     * @param {number} defaultY 击滚动条时，滚动条高度
+     */
+  }, {
+    key: "_mouseMove",
+    value: function _mouseMove(e, startY, defaultY) {
+      var eachNum = this.state.eachNum;
+      var nowTop = e.clientY;
+      var dataSum = this.cameraArray.length;
+      this.scrollbarTop = nowTop + defaultY - startY;
+      this.maxTop = (dataSum - eachNum) / dataSum * (this.treeTotalHeight - 30);
+      // 如果滚动条top超过最大top，则设置为最大高度
+      if (this.scrollbarTop > this.maxTop) {
+        this.scrollbarTop = this.maxTop;
+      } else if (this.scrollbarTop < 0) {
+        // 如果滚动条top小于0，则设置为0
+        this.scrollbarTop = 0;
+      }
+      // 根据滚动条高度除以总高度，再乘总数，得到渲染起始数
+      var beginSum = Math.ceil(this.scrollbarTop / (this.treeTotalHeight - 30) * dataSum);
+      var endSum;
+      // 防止起始数超过最大起始数
+      if (beginSum > dataSum - eachNum) {
+        beginSum = dataSum - eachNum;
+        endSum = dataSum;
+      } else {
+        endSum = beginSum + eachNum;
+      }
+      // 如果是搜索情况，且最后一个节点是更多加载，则执行加载更多操作
+      if (endSum === dataSum && this.isSearching && this.cameraArray[dataSum - 1].type === 'searchMore') {
+        // 移动到最后，且正在搜索中，最后一个节点是更多加载
+        // 执行搜索更多
+        this._continueSearching();
+      }
+      this.setState({
+        endSum: endSum,
+        beginSum: beginSum,
+        scrollbarTop: this.scrollbarTop + 'px'
+      });
+    }
+  }, {
+    key: "_clickFloder",
+    value:
+    //#endregion
+
+    //#region 文件夹操作相关代码
+    /**
+     * 点击文件夹操作
+     * @param {Object} item 被点击文件夹节点
+     * @param {number} index 文件夹在cameraArray中的位置
+     */
+    function _clickFloder(item, index) {
+      console.log('12222');
+      var id = item.id;
+      var org = item.parentId;
+      // 关闭文件夹
+      if (this.openTagArr.indexOf(id) > -1) {
+        if (this.isLocating) {
+          this.isLocating = false;
+          return;
+        }
+        this._closeFloder(id, index);
+      } else {
+        //展开文件夹
+        //文件夹已经打开过
+        if (this.dataObj[id] !== undefined) {
+          this._openFloderAgain(id, index);
+        } else {
+          // 将当前请求加入队列
+          // 如果没有正在请求队列则直接进行这次请求
+          if (this.queue.isEmpty) {
+            // 反馈正在加载
+            this._addLoadingNode(index + 1, this.dataObj[org]['floor'] + 1, id);
+            this._judgeScrollbarShow();
+            this.queue.enqueue({
+              item: item,
+              index: index,
+              type: 'floder',
+              needShow: true,
+              needLoadNode: true
+            });
+            this._openFloderFirst();
+            // 正在进行请求
+            this.isRequest = true;
+          } else {
+            // 有请求，反馈正在加载
+            if (!this.queue.isAlready(id)) {
+              this._addLoadingNode(index + 1, this.dataObj[org]['floor'] + 1, id);
+              this._judgeScrollbarShow();
+              this.queue.upQueueIndex(index, 1);
+            }
+            this.queue.enqueue({
+              item: item,
+              index: index,
+              type: 'floder',
+              needShow: true,
+              needLoadNode: false
+            });
+          }
+        }
+      }
+    }
+
+    /**
+     * 首次点开文件夹，有请求数据操作
+     */
+  }, {
+    key: "_openFloderFirst",
+    value: function _openFloderFirst() {
+      var _this8 = this;
+      // item 当前请求数据节点对象 index 当前请求数据节点的索引， 从队列中获取
+      var _this$queue$front = this.queue.front(),
+        item = _this$queue$front.item,
+        index = _this$queue$front.index;
+      var id = item.id,
+        resId = item.resId;
+      var org = item.parentId;
+      var floor = this.dataObj[org]['floor'] + 1;
+      this.dataObj[id] = {
+        data: [],
+        self: item
+      };
+      var resArray = this.dataObj[id];
+      this.treeLoader.setRequestObj({
+        item: item,
+        index: index
+      });
+      this.treeLoader.getNormalNode(resId, item).then(function (responseData) {
+        if (responseData === false) {
+          _this8.newNodeNum = 0;
+          return;
+        }
+        //请求有数据
+        if (responseData.length > 0) {
+          _this8.openTagArr.push(id);
+          if (!_this8.floderArr.indexOf(id) > -1) {
+            _this8.floderArr.push(id);
+          }
+          responseData = _this8.treeLoader.toTreeNode(responseData, id);
+          // 如果父节点设置了需要勾选，那么新打开的子节点进行勾选操作
+          if (
+          //item.loopCheck === LOOP_CHECK_TYPE.ALL ||
+          item.isCheck && _this8.props.isLoopCheck) {
+            for (var _index = 0, length = responseData.length; _index < length; _index++) {
+              responseData[_index].isCheck = true;
+              // 如果是组织节点，也添加上loopCheck
+              if (responseData[_index].isOrgNode === true) {
+                responseData[_index].loopCheck = LOOP_CHECK_TYPE.ALL;
+              }
+            }
+          }
+          // 二次请求，判断是否需要添加‘更多加载’
+          // 表示还有数据，需要添加
+          if (_this8.treeLoader.judgeNeedMore(resId)) {
+            responseData.push({
+              type: 'loadMore',
+              id: id,
+              resId: resId
+            });
+          }
+          _this8.newNodeNum = responseData.length;
+          responseData[responseData.length - 1].endTag = id;
+          Array.prototype.push.apply(resArray.data, responseData);
+          resArray.floor = floor;
+          // 挂载前如果有打开或者关闭文件夹需要更新节点插入的位置
+          index = _this8.queue.frontIndex();
+          // 如果当前加载的请求不需要加载，则不在数组中显示
+          if (_this8.queue.front().needShow === false || _this8.queue.front().hideTask === true || !_this8.isTreeRootExpand) {
+            _this8.newNodeNum = 0;
+            return;
+          }
+          // 如果最后一个为正在加载，则插入位置 + 2
+          if (_this8.cameraArray[index + 1] && _this8.cameraArray[index + 1].type === 'loading') {
+            var _this8$cameraArray;
+            (_this8$cameraArray = _this8.cameraArray).splice.apply(_this8$cameraArray, [index + 2, 0].concat(_toConsumableArray(resArray.data)));
+            // 否则 + 1
+          } else {
+            var _this8$cameraArray2;
+            (_this8$cameraArray2 = _this8.cameraArray).splice.apply(_this8$cameraArray2, [index + 1, 0].concat(_toConsumableArray(resArray.data)));
+          }
+          _this8._judgeScrollbarShow();
+          var sumObj = _this8._openFloder(id, index);
+          _this8.props.nodeLoadFinishedFunc(responseData, _this8.dataObj);
+          _this8.setState({
+            beginSum: sumObj.beginSum,
+            endSum: sumObj.endSum
+          }, _this8._moveScroll);
+        } else {
+          _this8.newNodeNum = 0;
+          _this8.forceUpdate();
+        }
+      }).catch(function (err) {
+        console.error(err);
+      }).finally(function () {
+        index = _this8.queue.frontIndex();
+        // 当前数据需要展示
+        if (_this8.queue.front().needShow !== false && _this8.queue.front().hideTask !== true && _this8.isTreeRootExpand) {
+          _this8._removeLoadingNode(index + 1);
+          _this8.queue.upQueueIndex(index, -1);
+        }
+        if (!_this8.isTreeRootExpand) {
+          _this8.cameraArray.splice(index + 1, 1);
+        }
+        _this8._judgeScrollbarShow();
+        // 没有高优先级任务，进行队列下一次请求
+        _this8.queue.upIndex(_this8.newNodeNum);
+        _this8.queue.dequeue();
+        // 重置请求到的数量
+        _this8.newNodeNum = 0;
+        // 如果队列不为空，进行队列下一次请求
+        if (!_this8.queue.isEmpty) {
+          _this8._nextQueue();
+        } else {
+          // 如果队列为空，将正在进行请求关闭
+          _this8.isRequest = false;
+        }
+        _this8.checkNode();
+      });
+    }
+
+    /**
+     * 再次打开文件夹
+     * @param {string} res 节点id
+     * @param {*} index 节点的索引
+     */
+  }, {
+    key: "_openFloderAgain",
+    value: function _openFloderAgain(res, index) {
+      // 如果当前请求打开的节点是正在刷新普通的节点
+      if (!this.queue.isEmpty && res === this.queue.front().item.id) {
+        return;
+      }
+      var resArray = this.dataObj[res];
+      // 此文件夹下有数据
+      if (resArray.data.length !== 0) {
+        var _this$cameraArray2;
+        this.openTagArr.push(res);
+        //遍历数组，如果其中有打开的文件夹，则打开
+        this._recursion(res);
+        (_this$cameraArray2 = this.cameraArray).splice.apply(_this$cameraArray2, [index + 1, 0].concat(_toConsumableArray(this.recursionArr)));
+        // 更新打开后队列中任务的index值
+        this.queue.upOpenIndex(index, this.recursionArr.length);
+        // 如果有正在进行的请求
+        if (!this.queue.isEmpty) {
+          // 如果打开的其中有正在加载的
+          for (var i = 0; i < this.recursionArr.length; i++) {
+            this.queue.needShow(this.recursionArr[i].id, index + i + 1);
+          }
+        }
+        this.recursionArr = [];
+      }
+      var sumObj = this._openFloder(res, index);
+      this._judgeScrollbarShow();
+      this.setState({
+        beginSum: sumObj.beginSum,
+        endSum: sumObj.endSum
+      }, this._moveScroll);
+    }
+
+    /**
+     * 关闭文件夹操作
+     * @param {string} id 节点id
+     * @param {number} index 文件夹在cameraArray中的位置
+     */
+  }, {
+    key: "_closeFloder",
+    value: function _closeFloder(id, index) {
+      // 如果当前文件夹正在请求数据
+      if (!this.queue.isEmpty && id === this.queue.front().item.id) {
+        return;
+      }
+      var cameraArray = this.cameraArray;
+      var _this$state5 = this.state,
+        endSum = _this$state5.endSum,
+        beginSum = _this$state5.beginSum,
+        eachNum = _this$state5.eachNum;
+      this._closeChildren(index, id);
+      this._judgeScrollbarShow();
+      //文件夹关闭后，处于最后面，beginSum需要上移一段位置
+      if (cameraArray[Math.ceil(endSum)] === undefined) {
+        endSum = cameraArray.length;
+        beginSum = cameraArray.length - eachNum;
+        beginSum = beginSum < 0 ? 0 : beginSum;
+      } else {
+        endSum = beginSum + eachNum;
+      }
+      //删除this.index里的记录
+      this.openTagArr.splice(this.openTagArr.indexOf(id), 1);
+      this.setState({
+        endSum: endSum,
+        beginSum: beginSum
+      }, this._moveScroll);
+    }
+
+    /**
+     * 遍历cameraArray，找到endTag，然后删除
+     * @param {*} index 被点击的节点在cameraArray中的index
+     * @param {*} res 被点击节点的id
+     */
+  }, {
+    key: "_closeChildren",
+    value: function _closeChildren(index, res) {
+      var cameraArray = this.cameraArray;
+      var item = this.dataObj[res].data;
+      var lastChildRes = item[item.length - 1].id;
+      // 如果最后一个子节点不是打开情况下,或者最后一个节点是加载节点
+      if (!this.openTagArr.indexOf(lastChildRes) > -1 || item[item.length - 1].type !== undefined) {
+        for (var i = index, len = cameraArray.length; i < len; i++) {
+          if (cameraArray[i].endTag === res) {
+            var needDeleteCount = i - index;
+            //判断最后一个节点是组织的情况 则再往下找一层id
+            if (cameraArray[i + 1] && cameraArray[i].isOrgNode && cameraArray[i + 1].parentId === cameraArray[i].id) {
+              this._closeChildren(index, cameraArray[i].id);
+            } else {
+              // 如果最后一个是加载中节点，则删除的数量+1
+              if (this.cameraArray[i + 1] && this.cameraArray[i + 1].type === 'loading') {
+                needDeleteCount += 1;
+              }
+              //删除数据
+              cameraArray.splice(index + 1, needDeleteCount);
+              // 如果有真正进行的请求
+              if (!this.queue.isEmpty) {
+                this.queue.needHide(index, index + needDeleteCount);
+              }
+              // 更新关闭后队列中任务的index值
+              this.queue.upCloseIndex(index, needDeleteCount);
+            }
+            break;
+          }
+        }
+      }
+    }
+
+    /**
+     * 根据子节点数，确认被打开的文件夹的位置
+     * @param {*} id 节点id
+     * @param {*} index 被点击文件夹在cameraArray中的index
+     */
+  }, {
+    key: "_openFloder",
+    value: function _openFloder(id, index) {
+      var _this$state6 = this.state,
+        endSum = _this$state6.endSum,
+        beginSum = _this$state6.beginSum,
+        eachNum = _this$state6.eachNum;
+      var childNodesLength = this.dataObj[id].data.length;
+      //子节点数量足够整个显示的数量，文件夹置顶
+      if (childNodesLength >= eachNum - 1) {
+        beginSum = index;
+        endSum = beginSum + eachNum;
+      } else {
+        // 还未出现滚动条时
+        if (endSum < eachNum) {
+          //当子节点数量+之前树的节点还是小于树最大容纳数，扩大endsum
+          if (childNodesLength + endSum < eachNum) {
+            endSum += childNodesLength;
+          } else {
+            // 子节点数量+被点击序列大于树最大容纳数，显示全子节点内容
+            if (childNodesLength + index + 1 > eachNum) {
+              endSum = index + childNodesLength + 1;
+              beginSum = endSum - eachNum;
+            } else {
+              endSum = eachNum;
+            }
+          }
+        } else {
+          // 已经出现滚动条
+          //子节点树+被点击序列大于endSum，显示全子节点内容
+          if (childNodesLength + index + 1 > endSum) {
+            endSum = index + childNodesLength + 1;
+            beginSum = endSum - eachNum;
+          }
+        }
+      }
+      return {
+        beginSum: beginSum,
+        endSum: endSum
+      };
+    }
+
+    /**
+     * 更多加载
+     * @param {number} index 更多加载按钮的索引
+     * @param {string} id 节点id
+     * @param {string} resId 资源id
+     * @param {string} parentId 父节点id
+     */
+  }, {
+    key: "_loadMore",
+    value: function _loadMore(index, id, resId, parentId) {
+      var item = {
+        id: id,
+        resId: resId,
+        parentId: parentId
+      };
+      // 删除更多加载
+      this.cameraArray.splice(index, 1);
+      // 如果没有请求直接开始加载更多
+      if (!this.isRequest) {
+        // 添加正在加载
+        this._addLoadingNode(index, this.dataObj[id].floor, id);
+        this.queue.enqueue({
+          item: item,
+          index: index,
+          type: 'loadMore',
+          needShow: true,
+          needLoadNode: true
+        });
+        this._loadMoreData();
+        // 开启正在进行请求
+        this.isRequest = true;
+      } else {
+        // 将加载请求排入队列
+        this._addLoadingNode(index, this.dataObj[id].floor, id);
+        this.queue.enqueue({
+          item: item,
+          index: index,
+          type: 'loadMore',
+          needShow: true,
+          needLoadNode: false
+        });
+      }
+    }
+
+    /**
+     * 请求更多加载的数据
+     */
+  }, {
+    key: "_loadMoreData",
+    value: function _loadMoreData() {
+      var _this9 = this;
+      var _this$queue$front2 = this.queue.front(),
+        item = _this$queue$front2.item,
+        index = _this$queue$front2.index;
+      var id = item.id,
+        resId = item.resId,
+        parentId = item.parentId;
+      var value = this.state.value;
+      var resArray = this.dataObj[id];
+      this.treeLoader.setRequestObj({
+        item: item,
+        index: index
+      });
+      this.treeLoader.continueGetNormalNode(resId, value).then(function (responseData) {
+        var _resArray$data, _this9$cameraArray;
+        // 挂载前如果有打开或者关闭文件夹需要更新节点插入的位置
+        index = _this9.queue.frontIndex();
+        if (responseData === false) {
+          _this9.newNodeNum = 0;
+          return false;
+        }
+        responseData = _this9.treeLoader.toTreeNode(responseData, id);
+
+        // 如果父节点设置了需要勾选，那么新打开的子节点进行勾选操作
+        if (_this9.dataObj[parentId].self.isCheck && _this9.props.isLoopCheck
+        //|| this.dataObj[parentId].self.loopCheck ===
+        // LOOP_CHECK_TYPE.SOME
+        ) {
+          for (var _index2 = 0, length = responseData.length; _index2 < length; _index2++) {
+            responseData[_index2].isCheck = true;
+            // 如果是组织节点，也添加上loopCheck
+            if (responseData[_index2].isOrgNode === true) {
+              responseData[_index2].loopCheck = LOOP_CHECK_TYPE.ALL;
+            }
+          }
+        }
+
+        // 二次请求，判断是否需要添加‘更多加载’
+        // 表示还有数据，需要添加
+        if (_this9.treeLoader.judgeNeedMore(resId)) {
+          responseData.push({
+            type: 'loadMore',
+            id: id,
+            resId: resId
+          });
+        }
+        _this9.newNodeNum = responseData.length;
+        responseData[responseData.length - 1].endTag = id;
+        (_resArray$data = resArray.data).splice.apply(_resArray$data, [resArray.data.length - 1, 1].concat(_toConsumableArray(responseData)));
+        // 如果当前加载的请求不需要加载，则不在数组中显示
+        if (_this9.queue.front().needShow === false || _this9.queue.front().hideTask === true || !_this9.isTreeRootExpand) {
+          _this9.newNodeNum = 0;
+          return;
+        }
+        (_this9$cameraArray = _this9.cameraArray).splice.apply(_this9$cameraArray, [index + 1, 0].concat(_toConsumableArray(responseData)));
+        _this9.props.nodeLoadFinishedFunc(responseData, _this9.dataObj);
+        _this9._moveScroll();
+      }).catch(function (err) {
+        console.error(err);
+      }).finally(function () {
+        index = _this9.queue.frontIndex();
+        // 如果当前加载的请求不需要加载
+        if (_this9.queue.front().needShow !== false && _this9.queue.front().hideTask !== true && _this9.isTreeRootExpand) {
+          _this9._removeLoadingNode(index);
+          _this9.queue.upQueueIndex(index, -1);
+        }
+        if (!_this9.isTreeRootExpand) {
+          _this9.cameraArray.splice(index, 1);
+        }
+        _this9._judgeScrollbarShow();
+        // 没有高优先级任务，进行队列下一次请求
+        _this9.queue.upIndeLoadMore(_this9.newNodeNum);
+        _this9.queue.dequeue();
+        // 重置请求到的数量
+        _this9.newNodeNum = 0;
+        // 如果有高优先级任务则执行
+        // 如果队列不为空，进行队列下一次请求
+        if (!_this9.queue.isEmpty) {
+          _this9._nextQueue();
+        } else {
+          // 如果队列为空，将正在进行请求关闭
+          _this9.isRequest = false;
+        }
+        _this9.checkNode();
+      });
+    }
+
+    /**
+     * 递归添加数据
+     * @param {String} res 节点id
+     */
+  }, {
+    key: "_recursion",
+    value: function _recursion(res) {
+      var resArray = this.dataObj[res];
+      for (var i = 0; i < resArray.data.length; i++) {
+        var resData = resArray.data[i];
+        this.recursionArr.push(resData);
+        //此文件夹处于打开状态
+        if (resData.type !== 'loadMore' && this.openTagArr.indexOf(resData.id) > -1) {
+          // 如果打开的文件夹正在刷新的，不在往下查询
+          if (this.queue.isEmpty || resArray.data[i].id !== this.queue.front().item.id) {
+            this._recursion(resData.id);
+          }
+        }
+      }
+      return true;
+    }
+
+    /**
+     * 根据 调整数量，改变可显示区域（暂时只使用在 加载中..上）
+     * @param {Number} changeNum 需要调整的数量
+     */
+  }, {
+    key: "_judgeShowRange",
+    value: function _judgeShowRange(changeNum) {
+      var _this$state7 = this.state,
+        endSum = _this$state7.endSum,
+        eachNum = _this$state7.eachNum;
+
+      // 如果显示部分还没出滚动条,修改可显示部分
+      if (endSum < eachNum) {
+        endSum += changeNum;
+      }
+      this.setState({
+        endSum: endSum
+      });
+    }
+
+    /**
+     * 进行下一次请求
+     */
+  }, {
+    key: "_nextQueue",
+    value: function _nextQueue() {
+      // 下一个业务的类型，如果是文件夹则执行请求文件夹
+      if (this.queue.front().type === 'floder') {
+        this._openFloderFirst();
+        // 下一个业务的类型，如果是加载则执行加载更多
+      } else if (this.queue.front().type === 'loadMore') {
+        this._loadMoreData();
+        // 下一个业务的类型，如果是刷新普通节点则执行刷新普通节点
+      } else if (this.queue.front().type === 'refreshNormal') {
+        this._refreshNormalNodeData();
+        // 下一个业务的类型，如果是刷新根节点
+      } else if (this.queue.front().type === 'refreshRoot') {
+        this.cameraArray = [];
+        this.dataObj = {};
+        this.dataObj.root = {
+          data: [],
+          floor: 1
+        };
+        this.isTreeRootExpand = true;
+        this._addRoot();
+        // 下一个业务的类型，如果是搜索
+      } else if (this.queue.front().type === 'search') {
+        this.cameraArray = [];
+        this.isSearching = true;
+        this.isTreeRootExpand = true;
+        this.dataObj = {};
+        this.dataObj.root = {
+          data: [],
+          floor: 1
+        };
+        this.floderArr = [];
+        this.openTagArr = [];
+        this.setState({
+          isScrollbarShow: false,
+          beginSum: 0
+        });
+        this._searchIng();
+      }
+    }
+
+    //#endregion
+
+    //#region 刷新部分代码
+
+    /**
+     * 刷新根节点
+     * 刷新所有缓存信息
+     * @param {Boolean} needSelectNode 刷新之后是否需要选中其中某个节点
+     */
+  }, {
+    key: "refreshRootNode",
+    value: function refreshRootNode(needSelectNode) {
+      if (needSelectNode) {
+        this.defaultClickNode = needSelectNode;
+      }
+      this.queue.hideTask();
+      this.cameraArray = [];
+      this.dataObj = {};
+      this.dataObj.root = {
+        data: [],
+        floor: 1
+      };
+      this.isTreeRootExpand = true;
+      if (!this.cameraArray[0] || this.cameraArray[0].type !== 'loading') {
+        this._addLoadingNode(0, 1, 'root');
+      }
+      if (this.queue.isEmpty) {
+        this._addRoot();
+        this.queue.enqueue('refreshRoot');
+      } else {
+        // 队列有任务，将当前任务排入队列
+        this.queue.enqueue('refreshRoot');
+      }
+    }
+
+    /**
+     * 刷新普通节点
+     * @param {string} id 刷新节点的id
+     * @param {string} resId 节点的资源id
+     * @param {number} index 节点的index
+     * @param {number} parentFloor 节点的floor
+     * @param {Boolean} needSelectNode 刷新之后是否需要选中其中某个节点
+     */
+  }, {
+    key: "refreshNormalNode",
+    value: function refreshNormalNode(id, resId, index, parentFloor, needSelectNode) {
+      if (needSelectNode) {
+        this.defaultClickNode = needSelectNode;
+      }
+      var item = {
+        id: id,
+        resId: resId,
+        parentFloor: parentFloor
+      };
+      //loader中需要整个节点的信息，业务层通过方法传下来的只有id和resid，所以这里进行替换
+      var refreshItem = this.cameraArray.find(function (item) {
+        return item.id === id && item.resId === resId;
+      });
+      if (refreshItem) {
+        item = _objectSpread(_objectSpread({}, refreshItem), {}, {
+          parentFloor: parentFloor
+        });
+      }
+      // 如果没有请求直接开始加载更多
+      var isOpen = this.openTagArr.indexOf(id) > -1 ? true : false;
+      // 节点处于展开状态
+      if (isOpen) {
+        this._closeFloder(id, index); //删除刷新节点的子节点
+        this.openTagArr.push(id);
+      }
+      if (needSelectNode && !isOpen) {
+        this.openTagArr.push(id);
+      }
+      if (this.queue.isEmpty) {
+        this._addLoadingNode(index + 1, parentFloor + 1 + 1, id);
+        this.queue.enqueue({
+          item: item,
+          index: index,
+          type: 'refreshNormal',
+          needShow: true,
+          needLoadNode: true,
+          needSelectNode: needSelectNode
+        });
+        this._refreshNormalNodeData();
+        // 开启正在进行请求，下次的请求直接加入队列
+        this.isRequest = true;
+      } else {
+        if (!this.queue.isAlready(id)) {
+          this._addLoadingNode(index + 1, parentFloor + 1 + 1, id);
+          this.queue.upQueueIndex(index, 1);
+        }
+        this.queue.enqueue({
+          item: item,
+          index: index,
+          type: 'refreshNormal',
+          needShow: true,
+          needLoadNode: false
+        });
+      }
+    }
+  }, {
+    key: "_refreshNormalNodeData",
+    value:
+    /**
+     * 请求刷新普通节点数据
+     */
+    function _refreshNormalNodeData() {
+      var _this0 = this;
+      var _this$queue$front3 = this.queue.front(),
+        item = _this$queue$front3.item,
+        index = _this$queue$front3.index,
+        needSelectNode = _this$queue$front3.needSelectNode;
+      var id = item.id,
+        resId = item.resId,
+        parentFloor = item.parentFloor;
+      if (needSelectNode) {
+        if (this.defaultClickNode) {
+          this.setState({
+            isClickNode: needSelectNode
+          });
+        }
+      }
+      // 节点是否处于展开状态
+      var isOpen = this.openTagArr.indexOf(id) > -1 ? true : false;
+      this.treeLoader.setRequestObj({
+        requestType: 'refresh',
+        item: item,
+        index: index
+      });
+      // this.isRefreshNormal = true;
+      this.treeLoader.refreshNormalNode(resId, item).then(function (responseData) {
+        // 挂载前如果有打开或者关闭文件夹需要更新节点插入的位置
+        index = _this0.queue.frontIndex();
+        if (responseData === false) {
+          _this0.newNodeNum = 0;
+          return;
+        }
+        //请求有数据
+        if (responseData.length > 0) {
+          if (_this0.dataObj[id]) {
+            var selfObj = _this0.dataObj[id].self;
+            _this0._clearChildrens(id);
+            // 定义存储数据对象
+            _this0.dataObj[id] = {
+              data: [],
+              floor: parentFloor + 1,
+              self: selfObj
+            };
+            responseData = _this0.treeLoader.toTreeNode(responseData, id);
+            // 判断是否需要加载更多
+            if (_this0.treeLoader.judgeNeedMore(resId)) {
+              responseData.push({
+                type: 'loadMore',
+                id: id,
+                resId: resId
+              });
+            }
+            responseData[responseData.length - 1].endTag = id;
+            _this0.dataObj[id].data = responseData;
+
+            // 节点处于展开状态
+            if (isOpen) {
+              _this0.newNodeNum = responseData.length;
+              // 如果当前加载的请求不需要加载，则不在数组中显示
+              if (_this0.queue.front().needShow === false || _this0.queue.front().hideTask === true || !_this0.isTreeRootExpand) {
+                _this0.newNodeNum = 0;
+                return;
+              }
+              // 如果最后一个为正在加载，则插入位置 + 2
+              if (_this0.cameraArray[index + 1] && _this0.cameraArray[index + 1].type === 'loading') {
+                var _this0$cameraArray;
+                (_this0$cameraArray = _this0.cameraArray).splice.apply(_this0$cameraArray, [index + 2, 0].concat(_toConsumableArray(responseData)));
+                // 否则 + 1
+              } else {
+                var _this0$cameraArray2;
+                (_this0$cameraArray2 = _this0.cameraArray).splice.apply(_this0$cameraArray2, [index + 1, 0].concat(_toConsumableArray(responseData)));
+              }
+              _this0._judgeScrollbarShow();
+              var showPosi = _this0._openFloder(id, index);
+              _this0.setState(showPosi);
+              _this0.props.nodeLoadFinishedFunc(responseData, _this0.dataObj);
+            } else {
+              _this0.floderArr.push(id);
+            }
+            _this0._moveScroll();
+          } else {
+            if (needSelectNode) {
+              if (!_this0.floderArr.indexOf(id) > -1) {
+                _this0.floderArr.push(id);
+              }
+              // 定义存储数据对象
+              _this0.dataObj[id] = {
+                data: [],
+                floor: parentFloor + 1,
+                self: _this0.cameraArray[index]
+              };
+              responseData = _this0.treeLoader.toTreeNode(responseData, id);
+              // 判断是否需要加载更多
+              if (_this0.treeLoader.judgeNeedMore(resId)) {
+                responseData.push({
+                  type: 'loadMore',
+                  id: id,
+                  resId: resId
+                });
+              }
+              responseData[responseData.length - 1].endTag = id;
+              _this0.dataObj[id].data = responseData;
+              _this0.newNodeNum = responseData.length;
+              // 如果当前加载的请求不需要加载，则不在数组中显示
+              if (_this0.queue.front().needShow === false || _this0.queue.front().hideTask === true || !_this0.isTreeRootExpand) {
+                _this0.newNodeNum = 0;
+                return;
+              }
+              // 如果最后一个为正在加载，则插入位置 + 2
+              if (_this0.cameraArray[index + 1] && _this0.cameraArray[index + 1].type === 'loading') {
+                var _this0$cameraArray3;
+                (_this0$cameraArray3 = _this0.cameraArray).splice.apply(_this0$cameraArray3, [index + 2, 0].concat(_toConsumableArray(responseData)));
+                // 否则 + 1
+              } else {
+                var _this0$cameraArray4;
+                (_this0$cameraArray4 = _this0.cameraArray).splice.apply(_this0$cameraArray4, [index + 1, 0].concat(_toConsumableArray(responseData)));
+              }
+              _this0._judgeScrollbarShow();
+              var _showPosi = _this0._openFloder(id, index);
+              _this0.setState(_showPosi);
+              _this0._moveScroll();
+              _this0.props.nodeLoadFinishedFunc(responseData, _this0.dataObj);
+            }
+          }
+        }
+      }).catch(function (err) {
+        console.error(err);
+      }).finally(function () {
+        index = _this0.queue.frontIndex();
+        if (_this0.queue.front().needShow !== false && _this0.queue.front().hideTask !== true && _this0.isTreeRootExpand) {
+          _this0._removeLoadingNode(index + 1);
+          _this0.queue.upQueueIndex(index, -1);
+        }
+        if (!_this0.isTreeRootExpand) {
+          _this0.cameraArray.splice(index + 1, 1);
+        }
+        _this0._judgeScrollbarShow();
+        _this0.queue.upIndex(_this0.newNodeNum);
+        _this0.queue.dequeue();
+        // 重置请求到的数量
+        _this0.newNodeNum = 0;
+        // 如果队列不为空，进行队列下一次请求
+        if (!_this0.queue.isEmpty) {
+          _this0._nextQueue();
+        } else {
+          // 如果队列为空，将正在进行请求关闭
+          _this0.isRequest = false;
+        }
+        _this0.checkNode();
+      });
+    }
+
+    /**
+     * 递归删除清除子节点
+     * @param {string} id 节点id
+     */
+  }, {
+    key: "_clearChildrens",
+    value: function _clearChildrens(id) {
+      // 如果节点对象存在
+      if (this.dataObj[id] !== undefined) {
+        var childrenNodes = this.dataObj[id].data;
+        childrenNodes.forEach(function (node) {
+          // 如果节点是组织节点
+          if (node.isOrgNode) {
+            var nodeId = node.id;
+            // 如果节点已经含有子节点内容，则遍历子节点，清除里面内容
+            if (this.floderArr.indexOf(nodeId) > -1) {
+              this.floderArr.splice(this.floderArr.indexOf(nodeId), 1);
+              this.openTagArr.indexOf(nodeId) > -1 && this.openTagArr.splice(this.openTagArr.indexOf(nodeId), 1);
+              this._clearChildrens(nodeId);
+            }
+          }
+        }, this);
+        this.dataObj[id] = {};
+      }
+    }
+
+    /**
+     * 重新设置TreeLoader 还有对应的DataType
+     * @param {TreeLoader} loader 为空则不变
+     * @param {Array} dateType
+     */
+  }, {
+    key: "reloadTreeLoaderDataTypes",
+    value: function reloadTreeLoaderDataTypes(loader, dateType) {
+      this.setState({
+        value: ''
+      });
+      if (loader && this.treeLoader !== loader) {
+        this.treeLoader = loader;
+        this.treeLoader.init(this.props.requestFinishedFunc, this.props.requestFailedFunc);
+      }
+      this.treeLoader.dataTypes = dateType;
+      this.refreshRootNode();
+    }
+    //#endregion
+
+    //#region 搜索部分代码
+    /**
+     * 搜索框onchange事件
+     * @param {*} e event
+     */
+  }, {
+    key: "_handleChange",
+    value: function _handleChange(e) {
+      this.setState({
+        value: e
+      });
+    }
+
+    /**
+     * 点击搜索
+     * 清空一些缓存信息，隐藏滚动条，起始位置归0
+     */
+  }, {
+    key: "_clickSearch",
+    value: function _clickSearch() {
+      var _this1 = this;
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      if (value === '') {
+        //当搜索关键字为空（点击清空图标或空关键词时回车搜索）,如果有备份的原组织树信息，则直接恢复数据，下一次再空值搜索就是刷新根节点了
+        if (this.bakTreeInfo && this.bakTreeStateInfo) {
+          this.setState(_objectSpread({}, this.bakTreeStateInfo));
+          Object.keys(this.bakTreeInfo).forEach(function (item) {
+            _this1[item] = _this1.bakTreeInfo[item];
+          });
+          this.searchValue = value;
+          this.isSearching = false;
+          this.bakTreeInfo = undefined;
+          this.bakTreeStateInfo = undefined;
+          if (this.isLocating) {
+            this.isLocating = false;
+            return;
+          }
+        } else {
+          if (!this.queue.isAlready('refreshRoot')) {
+            this.queue.hideTask();
+            this.cameraArray = [];
+            this.dataObj = {};
+            this.dataObj.root = {
+              data: [],
+              floor: 1
+            };
+            this.isTreeRootExpand = true;
+            this._addLoadingNode(0, 1, 'root');
+          }
+          this.refreshRootNode();
+        }
+      } else {
+        this.queue.hideTask();
+        this.searchValue = value;
+        this.isSearching = true;
+        this.isTreeRootExpand = true;
+
+        //有关键字进行搜索时只有在没有备份的情况下（非搜索模式下）进行备份
+        if (!this.bakTreeInfo || !this.bakTreeStateInfo) {
+          this.bakTreeInfo = {
+            cameraArray: _toConsumableArray(this.cameraArray),
+            dataObj: _objectSpread({}, this.dataObj),
+            floderArr: _toConsumableArray(this.floderArr),
+            openTagArr: _toConsumableArray(this.openTagArr)
+          };
+          this.bakTreeStateInfo = {
+            isScrollbarShow: this.state.isScrollbarShow,
+            beginSum: this.state.beginSum,
+            endSum: this.state.endSum,
+            eachNum: this.state.eachNum
+          };
+        }
+        this.cameraArray = [];
+        this.dataObj = {};
+        this.dataObj.root = {
+          data: [],
+          floor: 1
+        };
+        this.floderArr = [];
+        this.openTagArr = [];
+        this.setState({
+          isScrollbarShow: false,
+          beginSum: 0
+        });
+        this._addLoadingNode(0, 1, 'search');
+        this.queue.enqueue('search');
+        if (!this.queue.isEmpty) {
+          this._nextQueue();
+        }
+      }
+      var onSearch = this.props.onSearch;
+      typeof onSearch === 'function' && onSearch(value);
+    }
+
+    /**
+     * 开始搜索
+     */
+  }, {
+    key: "_searchIng",
+    value: function _searchIng() {
+      var _this10 = this;
+      if (!this.cameraArray[0] || this.cameraArray[0].type !== 'loading') {
+        this._addLoadingNode(0, 1, 'search');
+      }
+      var needFuzzySearch = this.props.needFuzzySearch;
+      var newValue = Array.from(this.searchValue).join(' ');
+      // 更新搜索目标域key值
+      this.lastSearchKey = this.clickOrgKey;
+      this.treeLoader.setRequestObj({
+        requestType: 'search'
+      });
+      this.treeLoader.getSearchNode(needFuzzySearch ? newValue : this.searchValue, this.clickOrgKey).then(function (returnData) {
+        _this10._removeLoadingNode(0);
+        _this10.queue.upQueueIndex(0, -1);
+        _this10.forceUpdate();
+        if (returnData === false) {
+          return;
+        }
+        //请求有数据
+        if (returnData.length > 0) {
+          returnData = _this10.treeLoader.toTreeNode(returnData, 'root');
+          // 判断是否有更多数据，需要更多加载提示语
+          if (_this10.treeLoader.judgeSearchMore()) {
+            returnData.push({
+              type: 'searchMore'
+            });
+          }
+          if (_this10.queue.front().hideTask !== true) {
+            _this10.cameraArray = returnData;
+            _this10.dataObj.root.data = _toConsumableArray(returnData);
+          }
+          _this10._judgeScrollbarShow();
+          _this10.props.nodeLoadFinishedFunc(returnData, _this10.dataObj);
+          _this10.setState({
+            beginSum: 0,
+            endSum: _this10.state.eachNum
+          }, _this10._moveScroll);
+        }
+      }).catch(function (err) {
+        _this10._removeLoadingNode(0);
+        _this10.queue.upQueueIndex(0, -1);
+        console.error(err);
+      }).finally(function () {
+        _this10.queue.dequeue();
+        _this10._removeLoadingNode(_this10.cameraArray.length - 1);
+        _this10._judgeScrollbarShow();
+        _this10.checkNode();
+        if (!_this10.queue.isEmpty) {
+          _this10._nextQueue();
+        } else {
+          // 如果队列为空，将正在进行请求关闭
+          _this10.isRequest = false;
+        }
+        _this10.isSearching = true;
+      });
+    }
+
+    /**
+     * 继续搜索
+     */
+  }, {
+    key: "_continueSearching",
+    value: function _continueSearching() {
+      var _this11 = this;
+      var value = this.state.value;
+      var cameraArray = this.cameraArray;
+      this.treeLoader.setRequestObj({
+        requestType: 'search'
+      });
+      this.treeLoader.continueGetSearchNode(value, this.lastSearchKey).then(function (returnData) {
+        if (returnData === false) {
+          return;
+        }
+        //请求有数据
+        if (returnData.length > 0) {
+          var cameraArrayLength = cameraArray.length;
+          returnData = _this11.treeLoader.toTreeNode(returnData, 'root');
+          if (_this11.queue.front() === undefined || _this11.queue.front().hideTask !== true) {
+            if (!_this11.treeLoader.judgeSearchMore()) {
+              var _this11$dataObj$root$;
+              cameraArray.splice.apply(cameraArray, [cameraArrayLength - 1, 1].concat(_toConsumableArray(returnData)));
+              (_this11$dataObj$root$ = _this11.dataObj.root.data).splice.apply(_this11$dataObj$root$, [cameraArrayLength - 1, 1].concat(_toConsumableArray(returnData)));
+            } else {
+              var _this11$dataObj$root$2;
+              cameraArray.splice.apply(cameraArray, [cameraArrayLength - 1, 0].concat(_toConsumableArray(returnData)));
+              (_this11$dataObj$root$2 = _this11.dataObj.root.data).splice.apply(_this11$dataObj$root$2, [cameraArrayLength - 1, 0].concat(_toConsumableArray(returnData)));
+            }
+          }
+          _this11._moveScroll();
+          _this11.props.nodeLoadFinishedFunc(returnData, _this11.dataObj);
+        }
+      }).catch(function (err) {
+        return console.error(err);
+      }).finally(function () {
+        _this11.checkNode();
+      });
+    }
+
+    /**
+     * 点击删除value
+     */
+  }, {
+    key: "_clickDelete",
+    value: function _clickDelete(value) {
+      var _this12 = this;
+      // 先进行删除，再判断是否需要查询
+      this.setState({
+        value: ''
+      }, function () {
+        var _this12$props = _this12.props,
+          onReset = _this12$props.onReset,
+          _this12$props$isClear = _this12$props.isClearAndSearch,
+          isClearAndSearch = _this12$props$isClear === void 0 ? true : _this12$props$isClear;
+        if (isClearAndSearch) {
+          _this12._clickSearch(value);
+        }
+        typeof onReset === 'function' && onReset();
+      });
+    }
+
+    /**
+     * 回车事件
+     */
+  }, {
+    key: "_getKey",
+    value: function _getKey(value) {
+      this._clickSearch(value);
+    }
+
+    //#endregion
+
+    //#region 节点相关
+    /**
+     * 添加正在加载节点
+     * @param {number} index 在cameraArray中添加的位置
+     * @param {number} floorNum 需要添加loading的层级，主要来计算padding的值
+     *  @param {String} id 正在加载唯一的key
+     */
+  }, {
+    key: "_addLoadingNode",
+    value: function _addLoadingNode(index, floorNum, id) {
+      var _this13 = this;
+      this.cameraArray.splice(index, 0, {
+        type: 'loading',
+        floorNum: floorNum,
+        id: id
+      });
+      this._judgeShowRange(1);
+      this.setState({
+        isLoading: true
+      }, function () {
+        _this13._judgeShowRange(1);
+      });
+    }
+
+    /**
+     * 移除正在加载节点
+     * @param {number} 在cameraArray中添加的位置
+     */
+  }, {
+    key: "_removeLoadingNode",
+    value: function _removeLoadingNode(index) {
+      var _this14 = this;
+      if (this.cameraArray[index] && this.cameraArray[index].type === 'loading') {
+        this.cameraArray.splice(index, 1);
+        this.setState({
+          isLoading: false
+        }, function () {
+          _this14._judgeShowRange(-1);
+        });
+      }
+    }
+
+    /**
+     * 选中节点，添加选中样式
+     * @param {Object} item 被点击节点对象
+     */
+  }, {
+    key: "_clickNode",
+    value: function _clickNode(item) {
+      this.setState({
+        isClickNode: item.id
+      });
+      if (!this.isSearching) {
+        // 如果点击的是组织，更新节点key，否则使用上一次搜索时的key值
+        this.clickOrgKey = ORG_TYPE_ARR.includes(item.resourceInfo.resType) ? item.resId : this.lastSearchKey;
+      }
+      this.defaultClickNode = '';
+    }
+  }, {
+    key: "setClickNode",
+    value:
+    /**
+     * 根据resId高亮需要节点
+     * @param {String} item 需要选中的resId
+     */
+    function setClickNode(resId) {
+      var id = '';
+      for (var i = 0; i < this.cameraArray.length; i++) {
+        var element = this.cameraArray[i];
+        if (resId === element.resId) {
+          id = element.id;
+        }
+      }
+      if (id) {
+        this.setState({
+          isClickNode: id
+        });
+        this.defaultClickNode = '';
+      }
+    }
+  }, {
+    key: "_resetSearchToTree",
+    value: function () {
+      var _resetSearchToTree2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+        var _this15 = this;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              return _context3.a(2, new Promise(function (resolve) {
+                if (_this15.state.value && _this15.isSearching) {
+                  _this15.setState({
+                    value: ''
+                  }, /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+                    return _regenerator().w(function (_context2) {
+                      while (1) switch (_context2.n) {
+                        case 0:
+                          _this15.isLocating = true;
+                          _this15._clickSearch();
+                          _context2.n = 1;
+                          return _this15._locateTreeNodeEnd();
+                        case 1:
+                          resolve();
+                        case 2:
+                          return _context2.a(2);
+                      }
+                    }, _callee2);
+                  })));
+                } else {
+                  resolve();
+                }
+              }));
+          }
+        }, _callee3);
+      }));
+      function _resetSearchToTree() {
+        return _resetSearchToTree2.apply(this, arguments);
+      }
+      return _resetSearchToTree;
+    }()
+    /**
+     * 定位某个节点到资源树中（自动打开对应的父级文件夹），高亮选择该节点
+     * resId 节点资源id 必填
+     * path 该节点的父级组织路径，选填 如 iccsid>org1>org2
+     * searchJumpToTree 如果是搜索模式下的定位，是否需要先切换为树模式
+     */
+  }, {
+    key: "locateTreeNode",
+    value: (function () {
+      var _locateTreeNode = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(resId) {
+        var _this16 = this;
+        var path,
+          searchJumpToTree,
+          pathArr,
+          reversePathArr,
+          itemIndex,
+          _loop2,
+          i,
+          _args5 = arguments;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              path = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : '';
+              searchJumpToTree = _args5.length > 2 && _args5[2] !== undefined ? _args5[2] : false;
+              if (resId) {
+                _context5.n = 1;
+                break;
+              }
+              return _context5.a(2);
+            case 1:
+              if (!this.isSearching) {
+                _context5.n = 4;
+                break;
+              }
+              if (!searchJumpToTree) {
+                _context5.n = 3;
+                break;
+              }
+              _context5.n = 2;
+              return this._resetSearchToTree();
+            case 2:
+              _context5.n = 4;
+              break;
+            case 3:
+              return _context5.a(2);
+            case 4:
+              if (path) {
+                _context5.n = 5;
+                break;
+              }
+              //无父级路径时直接根据资源编码去匹配树节点
+              this._selectClickNode(resId);
+              _context5.n = 11;
+              break;
+            case 5:
+              pathArr = path.split('/');
+              if (pathArr[0] === '') {
+                pathArr = pathArr.splice(1);
+              }
+              if (!(pathArr.length === 0)) {
+                _context5.n = 6;
+                break;
+              }
+              return _context5.a(2);
+            case 6:
+              reversePathArr = _toConsumableArray(pathArr).reverse();
+              itemIndex = this.cameraArray.findIndex(function (item) {
+                return item.resId === resId && item.resourceInfo.orgCode === reversePathArr[0];
+              });
+              if (!(itemIndex > -1)) {
+                _context5.n = 7;
+                break;
+              }
+              //当前树中已经渲染的节点直接能找到符合父级编码的设备时直接匹配定位即可
+              this._selectClickNode(resId, reversePathArr[0]);
+              return _context5.a(2);
+            case 7:
+              _loop2 = /*#__PURE__*/_regenerator().m(function _loop2(i) {
+                var itemIndex, newPathArr;
+                return _regenerator().w(function (_context4) {
+                  while (1) switch (_context4.n) {
+                    case 0:
+                      //从当前树已渲染节点从内部父级组织开始找，找到后就从此组织节点进入即可，如a->b->c->d，当前树渲染的节点直接能找到c，则只需要从c->d这样的组织结构去定位即可
+                      itemIndex = _this16.cameraArray.findIndex(function (item) {
+                        return item.resId === reversePathArr[i];
+                      });
+                      if (!(itemIndex > -1)) {
+                        _context4.n = 1;
+                        break;
+                      }
+                      newPathArr = pathArr.slice(pathArr.length - i - 1);
+                      _this16.findTreeNode(resId, newPathArr);
+                      return _context4.a(2, 1);
+                    case 1:
+                      return _context4.a(2);
+                  }
+                }, _loop2);
+              });
+              i = 0;
+            case 8:
+              if (!(i < reversePathArr.length)) {
+                _context5.n = 11;
+                break;
+              }
+              return _context5.d(_regeneratorValues(_loop2(i)), 9);
+            case 9:
+              if (!_context5.v) {
+                _context5.n = 10;
+                break;
+              }
+              return _context5.a(3, 11);
+            case 10:
+              i++;
+              _context5.n = 8;
+              break;
+            case 11:
+              return _context5.a(2);
+          }
+        }, _callee4, this);
+      }));
+      function locateTreeNode(_x2) {
+        return _locateTreeNode.apply(this, arguments);
+      }
+      return locateTreeNode;
+    }()
+    /**
+     * 在资源树中高亮选中某个节点并且调整滚动条
+     */
+    )
+  }, {
+    key: "_selectClickNode",
+    value: function _selectClickNode(resId, resParentOrgId) {
+      var _this17 = this;
+      var _this$state8 = this.state,
+        beginSum = _this$state8.beginSum,
+        endSum = _this$state8.endSum,
+        eachNum = _this$state8.eachNum;
+      var clickIndex = this.cameraArray.findIndex(function (item) {
+        return item.resId === resId;
+      });
+      if (resParentOrgId) {
+        clickIndex = this.cameraArray.findIndex(function (item) {
+          return item.resourceInfo.resCode === resId && item.resourceInfo.orgCode === resParentOrgId;
+        });
+      }
+      if (clickIndex === -1) {
+        if (resParentOrgId) {
+          clickIndex = this.cameraArray.findIndex(function (item) {
+            return item.resId === resParentOrgId;
+          });
+        }
+      }
+      if (clickIndex === -1) {
+        this.isLocating = false;
+        return;
+      }
+      if (endSum >= eachNum && (clickIndex > endSum || clickIndex < beginSum)) {
+        beginSum = clickIndex;
+        //当窗口变大，数量不够显示，需要调整位置
+        if (beginSum + eachNum > this.cameraArray.length) {
+          beginSum = this.cameraArray.length - eachNum;
+        }
+        endSum = beginSum + eachNum;
+        this.setState({
+          beginSum: beginSum,
+          endSum: endSum,
+          isClickNode: this.cameraArray[clickIndex].id
+        }, function () {
+          _this17.isLocating = false;
+        });
+      } else {
+        this.setState({
+          isClickNode: this.cameraArray[clickIndex].id
+        }, function () {
+          _this17.isLocating = false;
+        });
+      }
+    }
+
+    /**
+     * 按照组织路径依次打开对应文件夹
+     */
+  }, {
+    key: "findTreeNode",
+    value: (function () {
+      var _findTreeNode = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(resId, pathArr) {
+        var _this18 = this;
+        var resParentOrgId, _loop3, i;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
+            case 0:
+              if (resId) {
+                _context7.n = 1;
+                break;
+              }
+              return _context7.a(2);
+            case 1:
+              if (!(pathArr.length === 0)) {
+                _context7.n = 2;
+                break;
+              }
+              return _context7.a(2);
+            case 2:
+              resParentOrgId = '';
+              _loop3 = /*#__PURE__*/_regenerator().m(function _loop3(i) {
+                var itemIndex, hasMore, childItems, moreItemIndex;
+                return _regenerator().w(function (_context6) {
+                  while (1) switch (_context6.n) {
+                    case 0:
+                      itemIndex = _this18.cameraArray.findIndex(function (item) {
+                        return item.resId === pathArr[i];
+                      });
+                      if (!(itemIndex > -1)) {
+                        _context6.n = 8;
+                        break;
+                      }
+                      _this18.isLocating = true;
+                      _this18._selectClickNode(pathArr[i]);
+                      _context6.n = 1;
+                      return _this18._locateTreeNodeEnd();
+                    case 1:
+                      _this18.isLocating = true;
+                      _this18._clickFloder(_this18.cameraArray[itemIndex], itemIndex);
+                      _context6.n = 2;
+                      return _this18._locateTreeNodeEnd();
+                    case 2:
+                      //将加载更多处理完
+                      hasMore = true;
+                    case 3:
+                      if (!hasMore) {
+                        _context6.n = 7;
+                        break;
+                      }
+                      childItems = _this18.dataObj[_this18.cameraArray[itemIndex].id].data;
+                      moreItemIndex = childItems.findIndex(function (item) {
+                        return item.type === 'loadMore';
+                      });
+                      if (!(moreItemIndex > -1)) {
+                        _context6.n = 5;
+                        break;
+                      }
+                      _this18.isLocating = true;
+                      _this18._loadMore(itemIndex + moreItemIndex + 1, childItems[moreItemIndex].id, childItems[moreItemIndex].resId, childItems[moreItemIndex].id);
+                      _context6.n = 4;
+                      return _this18._locateTreeNodeEnd();
+                    case 4:
+                      _context6.n = 6;
+                      break;
+                    case 5:
+                      hasMore = false;
+                    case 6:
+                      _context6.n = 3;
+                      break;
+                    case 7:
+                      resParentOrgId = pathArr[i];
+                      _context6.n = 9;
+                      break;
+                    case 8:
+                      console.log('findTreeNode this.cameraArray has no org', pathArr[i]);
+                      return _context6.a(2, 1);
+                    case 9:
+                      return _context6.a(2);
+                  }
+                }, _loop3);
+              });
+              i = 0;
+            case 3:
+              if (!(i < pathArr.length)) {
+                _context7.n = 6;
+                break;
+              }
+              return _context7.d(_regeneratorValues(_loop3(i)), 4);
+            case 4:
+              if (!_context7.v) {
+                _context7.n = 5;
+                break;
+              }
+              return _context7.a(3, 6);
+            case 5:
+              i++;
+              _context7.n = 3;
+              break;
+            case 6:
+              this._selectClickNode(resId, resParentOrgId);
+            case 7:
+              return _context7.a(2);
+          }
+        }, _callee5, this);
+      }));
+      function findTreeNode(_x3, _x4) {
+        return _findTreeNode.apply(this, arguments);
+      }
+      return findTreeNode;
+    }())
+  }, {
+    key: "_locateTreeNodeEnd",
+    value: function () {
+      var _locateTreeNodeEnd2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
+        var _this19 = this;
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.n) {
+            case 0:
+              return _context8.a(2, new Promise(function (resolve, reject) {
+                if (_this19.locateTimer) {
+                  clearInterval(_this19.locateTimer);
+                  _this19.locateTimer = null;
+                }
+                _this19.locateTimer = setInterval(function () {
+                  if (!_this19.isLocating) {
+                    _this19.isLocating = false;
+                    clearInterval(_this19.locateTimer);
+                    _this19.locateTimer = null;
+                    resolve(false);
+                  }
+                }, 100);
+              }));
+          }
+        }, _callee6);
+      }));
+      function _locateTreeNodeEnd() {
+        return _locateTreeNodeEnd2.apply(this, arguments);
+      }
+      return _locateTreeNodeEnd;
+    }() //#endregion
+    //#region 提供父组件获取节点信息使用
+    /**
+     * 获取子节点信息
+     * @param {string} id 节点id
+     * @returns [Object] | null
+     */
+  }, {
+    key: "getChildrenNode",
+    value: function getChildrenNode(id) {
+      var returnData = null;
+      // 子节点信息还未添加
+      if (this.dataObj[id]) {
+        returnData = Object.assign([], this.dataObj[id].data);
+      }
+      return returnData;
+    }
+
+    /**
+     * 获取根节点信息
+     */
+  }, {
+    key: "getRootNode",
+    value: function getRootNode() {
+      return Object.assign([], this.dataObj[this.initRootNodeId].data);
+    }
+
+    /**
+     * 获取选中的节点的位置信息
+     */
+  }, {
+    key: "getClickNode",
+    value: function getClickNode() {
+      return this.selectNode;
+    }
+    //#endregion
+
+    //#region 树勾选功能
+    /**
+     * 在cameraArray中设置check状态
+     */
+  }, {
+    key: "_setCheckInCameraArray",
+    value: function _setCheckInCameraArray(item, isCheck) {
+      // 直接修改勾选状态;
+      item.isCheck = isCheck;
+      // 如果是组织节点，或者根节点，有级联操作
+      if (item.isOrgNode === true) {
+        if (this.props.isLoopCheck) {
+          // 组织节点保持全选
+          item.loopCheck = LOOP_CHECK_TYPE.ALL;
+          this._loopCheckChildItem(item, isCheck);
+        }
+      }
+
+      // 如果是根节点,不再继续操作
+      if (item.id === this.initRootNodeId || 'root' === item.id) {
+        this.forceUpdate();
+        return;
+      }
+      if (this.props.isLoopCheck) {
+        // 勾选后，对同级节点判断，是否需要勾选父节点
+        this._loopCheckParentItem(item, isCheck);
+        this.forceUpdate();
+      }
+    }
+
+    /**
+     * 循环设置子辈check状态
+     */
+  }, {
+    key: "_loopCheckChildItem",
+    value: function _loopCheckChildItem(item, check) {
+      var dataObj = this.dataObj[item.id];
+      // 如果无对应对象，或无数据
+      if (!dataObj || dataObj.data.length === 0) {
+        return;
+      }
+      var orgChildrenLength = dataObj.data.length;
+      for (var index = 0; index < orgChildrenLength; index++) {
+        var childItem = dataObj.data[index];
+        // 如果是特殊类型，不勾选
+        if (['loading', 'loadMore', 'searchMore'].indexOf(childItem.type) > -1) {
+          continue;
+        }
+        childItem.isCheck = check;
+        // 如果是组织节点，一直进行操作
+        if (childItem.isOrgNode === true) {
+          childItem.loopCheck = LOOP_CHECK_TYPE.ALL;
+          this._loopCheckChildItem(childItem, check);
+        }
+      }
+    }
+
+    /**
+     * 循环设置父辈check状态
+     */
+  }, {
+    key: "_loopCheckParentItem",
+    value: function _loopCheckParentItem(item, check) {
+      // 如果已经是根节点，不再操作
+      if (item.id === this.initRootNodeId || 'root' === item.id) {
+        return;
+      }
+      var parendObj = this.dataObj[item.parentId];
+      if (!parendObj || !parendObj.self) {
+        return;
+      }
+      var childrenObj = parendObj.data;
+      var childrenObjLength = childrenObj.length;
+
+      // 如果设置为不勾选，所有对应的父辈节点都设为不勾选
+      if (check === false) {
+        parendObj.self.isCheck = false;
+        // 记录状态
+        var checkStatus = false;
+        for (var index = 0; index < childrenObjLength; index++) {
+          //只要有一个勾选，就是半勾选
+          if (childrenObj[index].isCheck === true || childrenObj[index].loopCheck && childrenObj[index].loopCheck === LOOP_CHECK_TYPE.SOME) {
+            checkStatus = true;
+            break;
+          }
+        }
+        // 如果有其他勾选的，则是半选；如果没有，则去勾选
+        parendObj.self.loopCheck = checkStatus ? LOOP_CHECK_TYPE.SOME : LOOP_CHECK_TYPE.NONE;
+      } else {
+        // 记录状态
+        var _checkStatus = true;
+        for (var _index3 = 0; _index3 < childrenObjLength; _index3++) {
+          // 如果子节点中，有不是 勾选状态的，直接return
+          if (!childrenObj[_index3].isCheck) {
+            _checkStatus = false;
+            break;
+          }
+        }
+        // 如果子节点都是勾选状态的话，父节点也勾选
+        if (_checkStatus) {
+          parendObj.self.loopCheck = LOOP_CHECK_TYPE.ALL;
+          parendObj.self.isCheck = true;
+        } else {
+          // 如果不是全选，则设置为半选，异常保证
+          parendObj.self.loopCheck = LOOP_CHECK_TYPE.SOME;
+        }
+      }
+
+      // 如果是根节点，不再循环
+      if ('root' === parendObj.self.parentId) {
+        this.forceUpdate();
+        return;
+      }
+      this._loopCheckParentItem(parendObj.self, check);
+    }
+
+    /**
+     * 获取组织树加载节点信息
+     */
+  }, {
+    key: "getCameraArray",
+    value: function getCameraArray() {
+      return this.cameraArray;
+    }
+
+    /**
+     * 修改组织树节点信息
+     */
+  }, {
+    key: "setCameraArray",
+    value: function setCameraArray(index, key, value) {
+      if (this.cameraArray.length >= index + 1) {
+        this.cameraArray[index][key] = value;
+      }
+    }
+
+    /**
+     * 返回被勾选的节点
+     * @returns [all, org, noorg]
+     * 返回的数组解释，第一个属性：返回所有被勾选的信息
+     * 第二个属性：以组织为主进行返回。如果父组织勾选下，子节点不会返回；如果父组织无勾选，返回勾选的非组织节点
+     * 第三个属性：以非组织节点为主，只返回非组织勾选节点
+     */
+  }, {
+    key: "getCheckedItem",
+    value: function getCheckedItem() {
+      // 如果没有显示勾选框，直接返回false
+      if (this.props.checkboxTypes.length === 0) {
+        console.warn('无勾选数据');
+        return;
+      }
+      var all = [];
+      var org = [];
+      var node = [];
+      var partCheck = []; //返回半选状态的组织信息
+      var rootData = this.dataObj.root.data;
+      // 除根节点无数据
+      if (rootData.length === 0) {
+        console.warn('无数据');
+        return;
+      }
+      this._loopGetCheckedItem(this.dataObj.root.data, all, org, node, true, partCheck);
+      if (this.props.isPartCheckInfo) {
+        return [all, org, node, partCheck];
+      }
+      return [all, org, node];
+    }
+
+    /**
+     * 外部更新查询条件
+     */
+  }, {
+    key: "updateConditions",
+    value: function updateConditions(con) {
+      this.treeLoader.updateConditionsFunc(con);
+    }
+
+    /**
+     * 查询组织内的所有资源（递归查）
+     */
+  }, {
+    key: "getCheckedOrgResource",
+    value: function getCheckedOrgResource(data) {
+      var _this20 = this;
+      var _ref2 = data || {},
+        orgCodes = _ref2.orgCodes,
+        _ref2$searchValue = _ref2.searchValue,
+        searchValue = _ref2$searchValue === void 0 ? '' : _ref2$searchValue;
+      var blankResult = Promise.resolve([]);
+      var queryOrgCodes = [];
+      var resourceList = [];
+      if (orgCodes && orgCodes.length > 0) {
+        queryOrgCodes = orgCodes;
+      } else {
+        var checkData = this.getCheckedItem()[1];
+        var checkResource = this.getCheckedItem()[2];
+        if (!checkData || checkData.length === 0) {
+          return blankResult;
+        }
+        var checkOrgData = checkData.filter(function (item) {
+          return item.isOrgNode;
+        });
+        if (checkOrgData.length === 0) {
+          return Promise.resolve(checkData);
+        }
+        var resource = checkResource === null || checkResource === void 0 ? void 0 : checkResource.filter(function (item) {
+          return !item.isOrgNode && item.nodeText.indexOf(searchValue) > -1;
+        });
+        resourceList.push.apply(resourceList, _toConsumableArray(resource));
+        queryOrgCodes = checkOrgData.map(function (item) {
+          return item.resId;
+        });
+      }
+      function queryResource(_x5, _x6, _x7) {
+        return _queryResource.apply(this, arguments);
+      }
+      function _queryResource() {
+        _queryResource = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(loader, codes, key) {
+          var data, _iterator, _step, code, returnData, _t;
+          return _regenerator().w(function (_context0) {
+            while (1) switch (_context0.p = _context0.n) {
+              case 0:
+                data = [];
+                _iterator = _createForOfIteratorHelper(codes);
+                _context0.p = 1;
+                _iterator.s();
+              case 2:
+                if ((_step = _iterator.n()).done) {
+                  _context0.n = 5;
+                  break;
+                }
+                code = _step.value;
+                _context0.n = 3;
+                return loader.getCheckedOrgResource(code, key);
+              case 3:
+                returnData = _context0.v;
+                if (returnData && returnData.length > 0) {
+                  returnData = loader.toTreeNode(returnData, '');
+                  data.push.apply(data, _toConsumableArray(returnData));
+                }
+              case 4:
+                _context0.n = 2;
+                break;
+              case 5:
+                _context0.n = 7;
+                break;
+              case 6:
+                _context0.p = 6;
+                _t = _context0.v;
+                _iterator.e(_t);
+              case 7:
+                _context0.p = 7;
+                _iterator.f();
+                return _context0.f(7);
+              case 8:
+                return _context0.a(2, data);
+            }
+          }, _callee8, null, [[1, 6, 7, 8]]);
+        }));
+        return _queryResource.apply(this, arguments);
+      }
+      return new Promise(/*#__PURE__*/function () {
+        var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(resolve, reject) {
+          var _data;
+          var data;
+          return _regenerator().w(function (_context9) {
+            while (1) switch (_context9.n) {
+              case 0:
+                _context9.n = 1;
+                return queryResource(_this20.treeLoader, queryOrgCodes, searchValue);
+              case 1:
+                data = _context9.v;
+                //把在树上勾选的资源节点和递归查出来的资源进行去重（按照编码、资源类型两个维度去重）
+                data = (_data = data) === null || _data === void 0 ? void 0 : _data.filter(function (item) {
+                  return resourceList.every(function (item1) {
+                    return item1.resourceInfo.resCode !== item.resourceInfo.resCode && item1.resourceInfo.resType !== item.resourceInfo.resType;
+                  });
+                });
+                resourceList.push.apply(resourceList, _toConsumableArray(data));
+                resolve(resourceList);
+              case 2:
+                return _context9.a(2);
+            }
+          }, _callee7);
+        }));
+        return function (_x8, _x9) {
+          return _ref3.apply(this, arguments);
+        };
+      }());
+    }
+
+    /**
+     * 循环获取所有勾选信息
+     * @param {Object} data 数据源
+     * @param {Array} all
+     * @param {Array} org
+     * @param {Array} node
+     * @param {Boolean} addOrg 子节点是否需要被添加
+     */
+  }, {
+    key: "_loopGetCheckedItem",
+    value: function _loopGetCheckedItem(data, all, org, node, addOrg, partCheck) {
+      // 循环所有字节点，获取勾选数据
+      for (var index = 0, length = data.length; index < length; index++) {
+        var childItem = data[index];
+        var isOrgNode = childItem.isOrgNode,
+          _childItem$isCheck = childItem.isCheck,
+          isCheck = _childItem$isCheck === void 0 ? false : _childItem$isCheck,
+          loopCheck = childItem.loopCheck;
+        var needLoop = false; // 是否需要循环子节点
+        var needAddOrg = true;
+        if (!this.props.isLoopCheck) {
+          needLoop = true;
+        }
+        // 如果是勾选情况，all直接添加
+        if (isCheck === true) {
+          all.push(childItem);
+          if (addOrg) {
+            org.push(childItem);
+          }
+        }
+        //组织节点部分勾选，则返回部分勾选的信息
+        if (loopCheck === LOOP_CHECK_TYPE.SOME) {
+          partCheck.push(childItem);
+        }
+        switch (true) {
+          case isCheck === true && isOrgNode === true:
+            // 组织节点勾选
+            if (this.props.isLoopCheck) {
+              needAddOrg = false;
+            }
+            needLoop = true;
+            break;
+          case isCheck === true && isOrgNode === false:
+            // 非组织节点勾选
+            node.push(childItem);
+            break;
+          case isCheck === false && isOrgNode === true && loopCheck === LOOP_CHECK_TYPE.SOME:
+            // 组织节点部分勾选
+            needLoop = true;
+            break;
+          default:
+            break;
+        }
+        if (needLoop !== true) {
+          continue;
+        }
+        var childObj = this.dataObj[childItem.id];
+        // 如果该组织无子数据
+        if (!childObj || childObj.data.length === 0) {
+          continue;
+        }
+        this._loopGetCheckedItem(childObj.data, all, org, node, needAddOrg, partCheck);
+      }
+    }
+
+    /**
+     * 获取当前选中的节点（非勾选）
+     */
+  }, {
+    key: "getSelectItem",
+    value: function getSelectItem() {
+      var isClickNode = this.state.isClickNode;
+      for (var key in this.dataObj) {
+        if (this.dataObj[key].data && this.dataObj[key].data.length > 0) {
+          var sonData = this.dataObj[key].data;
+          for (var i = 0, dataLen = sonData.length; i < dataLen; i++) {
+            var data = sonData[i];
+            if (this.defaultClickNode) {
+              if (data.resId === this.defaultClickNode) {
+                return data;
+              }
+            } else {
+              if (data.id === isClickNode) {
+                return data;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    /**
+     * 取消所有勾选
+     */
+  }, {
+    key: "cancelAllCheckItem",
+    value: function cancelAllCheckItem() {
+      for (var key in this.dataObj) {
+        var data = this.dataObj[key];
+        for (var j = 0, dataLen = data.data.length; j < dataLen; j++) {
+          data.data[j].isCheck = false;
+          data.data[j].loopCheck = LOOP_CHECK_TYPE.NONE;
+        }
+      }
+      this.forceUpdate();
+      var onReset = this.props.onReset;
+      typeof onReset === 'function' && onReset();
+    }
+
+    /**
+     * 业务中一键勾选节点类型
+     * @param {Array} 一键勾选的节点类型
+     */
+  }, {
+    key: "checkNodeByTypes",
+    value: function checkNodeByTypes(types) {
+      var _this21 = this;
+      var _this$props4 = this.props,
+        onReset = _this$props4.onReset,
+        checkboxTypes = _this$props4.checkboxTypes;
+      for (var key in this.dataObj) {
+        var data = this.dataObj[key];
+        // 当前组织下是否有节点被选中
+        var tempCheck = false;
+        var _loop4 = function _loop4() {
+          var item = data.data[j];
+          // 当前节点是否被选中
+          var isCheck = checkboxTypes.indexOf(item.resourceInfo.resType) > -1 && types.indexOf(item.resourceInfo.resType) > -1 || types.some(function (res) {
+            return res.resId === item.resId;
+          }) || types.some(function (res) {
+            return res.id === item.id;
+          }) || types.includes(item.resId) || types.includes(item.id) ? true : false;
+          // 设置当前节点是否被选中
+          item.isCheck = isCheck;
+          // 当前组织下如果有节点被选中，保存一下，后边用来据此对父节点进行选中操作
+          if (isCheck) {
+            tempCheck = true;
+          }
+          // 如过当前节点是组织节点或者域节点，需要对当前节点子节点循环设置状态
+          if (item.isOrgNode === true) {
+            item.loopCheck = isCheck ? LOOP_CHECK_TYPE.ALL : LOOP_CHECK_TYPE.NONE;
+            _this21._loopCheckChildItem(item, isCheck);
+          }
+        };
+        for (var j = 0, dataLen = data.data.length; j < dataLen; j++) {
+          _loop4();
+        }
+        // 如果有节点被选中，根据最后一个节点信息去设置其父节点选中状态
+        if (tempCheck) {
+          this._loopCheckParentItem(data.data[data.data.length - 1], true);
+        }
+      }
+      this.forceUpdate();
+      typeof onReset === 'function' && onReset();
+    }
+    //#endregion
+
+    //#region 显示内容控制
+    /**
+     * 根据树框的高度改变可显示
+     */
+  }, {
+    key: "_changeByTreeHeight",
+    value: function _changeByTreeHeight() {
+      var _this$treeBox$current = this.treeBox.current,
+        clientHeight = _this$treeBox$current.clientHeight,
+        clientWidth = _this$treeBox$current.clientWidth;
+      //获取树的宽
+      if (this.treeBoxUlWidth !== clientWidth) {
+        this._recoverLeftScroll();
+        this.treeBoxUlWidth = clientWidth;
+      }
+      //获取树的高度
+      if (this.treeTotalHeight !== clientHeight) {
+        this.treeTotalHeight = clientHeight;
+        //计算出可容纳的数据个数（向下取整），显示完整的节点
+        return Math.floor(this.treeTotalHeight / this.perHeight);
+      } else {
+        return this.state.eachNum;
+      }
+    }
+
+    /**
+     * 渲染的时候重新计算可显示数量
+     */
+  }, {
+    key: "_renderRecalcNum",
+    value: function _renderRecalcNum() {
+      var _this22 = this;
+      this._leftDistance();
+      var _this$state9 = this.state,
+        eachNum = _this$state9.eachNum,
+        beginSum = _this$state9.beginSum,
+        isLastNodeNeedEllipsis = _this$state9.isLastNodeNeedEllipsis;
+      var needShowNum = this._changeByTreeHeight();
+      // 如果需要显示的和已显示数量相同，不操作
+      if (eachNum === needShowNum) {
+        if (this.zeroTag === 0 && needShowNum === 0) {
+          this.zeroTag++;
+          this.forceUpdate();
+        } else {
+          this.zeroTag = 0;
+        }
+      } else {
+        this.zeroTag = 0;
+        // 如果是出现的横向滚动条，且需要显示和已显示数量不相同了
+        // 说明要出事情了，赶紧把最后一个节点显示设置成省略号，防止死循环
+        if (this.needLeftScroll) {
+          this.setState({
+            isLastNodeNeedEllipsis: !isLastNodeNeedEllipsis
+          });
+          // 因为出现了省略号，还是之前的显示数量
+          // needShowNum = eachNum;
+        }
+        this.setState({
+          endSum: beginSum + needShowNum,
+          eachNum: needShowNum
+        }, function () {
+          if (_this22.isTreeRootExpand) {
+            _this22._judgeScrollbarShow();
+            _this22._moveScroll();
+          }
+        });
+      }
+    }
+  }, {
+    key: "render",
+    value:
+    // TODO 写一个自动计算显示区域、是否需要滚动条等功能完全的函数
+    //#endregion
+
+    function render() {
+      var _this23 = this;
+      var _this$state0 = this.state,
+        endSum = _this$state0.endSum,
+        beginSum = _this$state0.beginSum,
+        isScrollbarShow = _this$state0.isScrollbarShow,
+        isClickNode = _this$state0.isClickNode,
+        mouseEnterNode = _this$state0.mouseEnterNode,
+        scrollbarHeight = _this$state0.scrollbarHeight,
+        scrollbarTop = _this$state0.scrollbarTop,
+        isLastNodeNeedEllipsis = _this$state0.isLastNodeNeedEllipsis;
+      var _this$props5 = this.props,
+        onDoubleClick = _this$props5.onDoubleClick,
+        onRightClick = _this$props5.onRightClick,
+        onMouseEnter = _this$props5.onMouseEnter,
+        onMouseLeave = _this$props5.onMouseLeave,
+        onClick = _this$props5.onClick,
+        onDragStart = _this$props5.onDragStart,
+        onDragEnd = _this$props5.onDragEnd,
+        _this$props5$isNeedSe = _this$props5.isNeedSearch,
+        isNeedSearch = _this$props5$isNeedSe === void 0 ? false : _this$props5$isNeedSe,
+        treeTitleNode = _this$props5.treeTitleNode,
+        onCheck = _this$props5.onCheck,
+        theme = _this$props5.theme,
+        searchPlaceholder = _this$props5.searchPlaceholder,
+        textLocale = _this$props5.textLocale,
+        hiddenResList = _this$props5.hiddenResList;
+      var items = [];
+      var renderArr = [];
+      var renderArrLength = this.cameraArray.length >= endSum ? endSum : this.cameraArray.length;
+      var searchHeight = isNeedSearch || treeTitleNode ? '50px' : '0px'; // 搜索框的高度
+      var underlyingItem = 0;
+      //获取渲染数组
+      for (var i = beginSum; i < renderArrLength; i++) {
+        renderArr.push(this.cameraArray[i]);
+      }
+      if (renderArr.length === 0) {
+        //无结果
+        items.push(/*#__PURE__*/React.createElement(LoadNode, {
+          key: "loadNone",
+          floorNum: 1,
+          value: textLocale === null || textLocale === void 0 ? void 0 : textLocale.loadSearchNone
+        }));
+      }
+      var _loop5 = function _loop5(_i) {
+        var item = renderArr[_i];
+        if (hiddenResList && hiddenResList.length > 0 && (hiddenResList.some(function (res) {
+          return res.resId === item.resId;
+        }) || hiddenResList.some(function (res) {
+          return res.id === item.id;
+        }) || hiddenResList.includes(item.resId) || hiddenResList.includes(item.id))) {
+          return 1; // continue
+        }
+        if (_typeof(item) === 'object' && !item.type && _this23.dataObj[item.parentId]) {
+          var treeKey = item.id;
+          var treeParent = item.parentId;
+          var treeValue = item.nodeText;
+          var isFloder = _this23.floderArr.indexOf(treeKey) > -1 ? true : false;
+          var isOpen = _this23.openTagArr.indexOf(treeKey) > -1 ? true : false;
+          var needClickStyle = '';
+          // 是否是最后一个节点
+          var isLast = _i === renderArr.length - 1;
+          if (_this23.defaultClickNode) {
+            needClickStyle = isClickNode === item.resId ? 'clickedNodeOnTree' : '';
+          } else {
+            needClickStyle = isClickNode === treeKey ? 'clickedNodeOnTree' : '';
+          }
+          var needMouseEnterStyle = '';
+          needMouseEnterStyle = mouseEnterNode === treeKey ? 'mouseEnterTreeNode' : '';
+          var floorNum = _this23.dataObj[treeParent]['floor'];
+          if (floorNum > underlyingItem) {
+            underlyingItem = floorNum;
+          }
+          if (needClickStyle) {
+            _this23.selectNode = {
+              item: item,
+              index: _i + beginSum,
+              floor: floorNum
+            };
+          }
+          // 点击节点的+-icon：节点是文件夹类型，则是点击文件夹功能；节点是根节点，则是点击根节点功能
+          var iconLeftClick = treeParent === 'root' && _this23.isSearching === false ? _this23._clickRoot : item.isOrgNode || item.resourceInfo && item.resourceInfo.resType === 3002 ? function () {
+            _this23._clickFloder(item, _i + beginSum);
+          } : null;
+          var iconClass = isOpen ? item.iconExpandedUrl : item.iconUrl;
+
+          /**
+           * 勾选操作时触发
+           * @param {Event} event 事件
+           * @param {Boolean} checked 勾选状态
+           */
+          var checkFunc = function checkFunc(event, checked) {
+            // 如果勾选了，把对应item的状态设置成checked
+            if (checked === true) {
+              _this23._setCheckInCameraArray(item, true);
+            } else {
+              // 如果是去勾选，把对应item的状态设置成空
+              _this23._setCheckInCameraArray(item, false);
+            }
+            event.stopPropagation();
+            typeof onCheck === 'function' && onCheck(event, item, checked);
+            _this23.forceUpdate();
+          };
+
+          // 节点左击
+          var click = function click(e) {
+            // 如果点击的是选择框，不触发
+
+            if (e.target.getAttribute('type') === 'checkbox') {
+              return;
+            }
+            _this23._clickNode(item);
+            typeof onClick === 'function' && onClick(e, item, _i + beginSum, floorNum);
+            if (_this23.showCheckboxTypes.indexOf(item.resourceInfo.resType) < 0) {
+              return;
+            }
+            //checkFunc(e, !item.isCheck);
+          };
+
+          // 节点双击
+          var doubleClick = function doubleClick(e) {
+            // 如果点击的是选择框，不触发
+            if (e.target.getAttribute('type') === 'checkbox') {
+              return;
+            }
+            (item.isOrgNode || item.parentId === 'root' && !_this23.isSearching || item.resourceInfo && item.resourceInfo.resType === 3002) && iconLeftClick();
+            typeof onDoubleClick === 'function' && onDoubleClick(e, item, _this23.isSearching);
+          };
+
+          // 节点右击
+          var rightClick = function rightClick(e) {
+            _this23._clickNode(item);
+            typeof onRightClick === 'function' && onRightClick(e, item, _i + beginSum, floorNum);
+          };
+
+          // 鼠标移入
+          var mouseEnter = function mouseEnter(e) {
+            _this23._mouseEvent('mouseEnter', item);
+            typeof onMouseEnter === 'function' && onMouseEnter(e, item, _i + beginSum, floorNum);
+          };
+
+          // 鼠标移出
+          var mouseLeave = function mouseLeave(e) {
+            _this23._mouseEvent('mouseLeave', item);
+            typeof onMouseLeave === 'function' && onMouseLeave(e, item, _i + beginSum, floorNum);
+          };
+
+          // 拖拽事件，添加当前拖拽节点对象，父节点获取data后需要JSON.parse解析
+          var dragStart = function dragStart(e) {
+            // 如果业务不允许拖拽则不拖拽
+            if (item.canDrag === false) {
+              e.preventDefault();
+              return;
+            }
+            _this23._clickNode(item);
+            var target = JSON.stringify(item);
+            if (_isIe()) {
+              var obj = {
+                typetree: 'treeNode',
+                targetnode: target
+              };
+              var objStr = JSON.stringify(obj);
+              e.dataTransfer.setData('text', objStr);
+            } else {
+              e.dataTransfer.setData('typetree', 'treeNode');
+              e.dataTransfer.setData('targetnode', target);
+            }
+            typeof onDragStart === 'function' && onDragStart(e, item);
+          };
+          var dragEnd = function dragEnd(e) {
+            typeof onDragEnd === 'function' && onDragEnd(e, item);
+          };
+
+          // 如果showCheckboxTypes中包含当前节点的type，则显示勾选框
+          var showCheckbox = _this23.showCheckboxTypes.indexOf(item.resourceInfo.resType) > -1 ? true : false;
+          if (_this23.isShowOrgInfo) {
+            if (item.isDisPlay) {
+              items.push(/*#__PURE__*/React.createElement(TreeNode, {
+                key: treeKey,
+                value: treeValue,
+                iconClass: iconClass,
+                isFloder: isFloder,
+                isOpen: isOpen,
+                iconLeftClick: iconLeftClick,
+                click: click,
+                rightClick: rightClick,
+                dragStart: dragStart,
+                dragEnd: dragEnd,
+                mouseEnter: mouseEnter,
+                mouseLeave: mouseLeave,
+                doubleClick: doubleClick,
+                floorNum: floorNum,
+                needClickStyle: needClickStyle,
+                needMouseEnterStyle: needMouseEnterStyle,
+                targetNode: item,
+                isSearching: _this23.isSearching,
+                checkFunc: checkFunc,
+                showCheckbox: showCheckbox,
+                leftDistance: _this23._leftDistance,
+                isNeedEllipsis: isLastNodeNeedEllipsis && isLast
+              }));
+            }
+          } else {
+            items.push(/*#__PURE__*/React.createElement(TreeNode, {
+              key: treeKey,
+              value: treeValue,
+              iconClass: iconClass,
+              isFloder: isFloder,
+              isOpen: isOpen,
+              iconLeftClick: iconLeftClick,
+              click: click,
+              rightClick: rightClick,
+              dragStart: dragStart,
+              dragEnd: dragEnd,
+              mouseEnter: mouseEnter,
+              mouseLeave: mouseLeave,
+              doubleClick: doubleClick,
+              floorNum: floorNum,
+              needClickStyle: needClickStyle,
+              targetNode: item,
+              isSearching: _this23.isSearching,
+              needMouseEnterStyle: needMouseEnterStyle,
+              checkFunc: checkFunc,
+              showCheckbox: showCheckbox,
+              leftDistance: _this23._leftDistance,
+              isNeedEllipsis: isLastNodeNeedEllipsis && isLast
+            }));
+          }
+        } else if ((item === null || item === void 0 ? void 0 : item.type) === 'loading') {
+          //正在加载
+          items.push(/*#__PURE__*/React.createElement(LoadNode, {
+            key: item.type + item.id,
+            floorNum: item.floorNum,
+            value: textLocale === null || textLocale === void 0 ? void 0 : textLocale.loadingPrompt
+          }));
+        } else if ((item === null || item === void 0 ? void 0 : item.type) === 'loadMore') {
+          //加载更多
+          var _floorNum = _this23.dataObj[item.id] ? _this23.dataObj[item.id].floor : 1;
+          items.push(/*#__PURE__*/React.createElement(LoadNode, {
+            key: item.type,
+            floorNum: _floorNum,
+            value: textLocale === null || textLocale === void 0 ? void 0 : textLocale.loadMorePrompt,
+            click: function click() {
+              _this23._loadMore(_i + beginSum, item.id, item.resId, item.id);
+            }
+          }));
+        } else if ((item === null || item === void 0 ? void 0 : item.type) === 'searchMore') {
+          items.push(/*#__PURE__*/React.createElement(LoadNode, {
+            key: item.type,
+            floorNum: 1,
+            value: textLocale === null || textLocale === void 0 ? void 0 : textLocale.loadingPrompt,
+            isSearching: _this23.isSearching
+          }));
+        }
+      };
+      for (var _i = 0; _i < renderArr.length; _i++) {
+        if (_loop5(_i)) continue;
+      }
+      return /*#__PURE__*/React.createElement(Fragment, null, (isNeedSearch || treeTitleNode) && /*#__PURE__*/React.createElement("div", {
+        className: "".concat(treePrefix, "-title-container")
+      }, isNeedSearch === 'right' && treeTitleNode, isNeedSearch && /*#__PURE__*/React.createElement(UInput, {
+        allowClear: true,
+        theme: theme,
+        className: "".concat(treePrefix, "-search"),
+        placeholder: searchPlaceholder || (textLocale === null || textLocale === void 0 ? void 0 : textLocale.pleaseEnter),
+        value: this.state.value,
+        onChange: this._handleChange,
+        onEnterPress: this._getKey,
+        onSearch: this._getKey,
+        isClearAndSearch: false,
+        onClear: this._clickDelete
+      }), (isNeedSearch === 'left' || typeof isNeedSearch === 'boolean') && treeTitleNode), /*#__PURE__*/React.createElement("div", {
+        className: "".concat(treePrefix, "-box"),
+        style: {
+          height: "calc(100% - ".concat(searchHeight, ")")
+        },
+        ref: "treeMain"
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "".concat(treePrefix, "-box-main"),
+        style: {
+          height: '100%'
+        },
+        ref: this.treeBox,
+        onWheel: this._commonwheel,
+        id: "treeContent"
+      }, /*#__PURE__*/React.createElement("ul", {
+        className: "".concat(treePrefix, "-box-ul"),
+        ref: "treeBoxUl",
+        style: {
+          overflowX: this.props.isIllegalAnalysis ? 'hidden' : ''
+        }
+      }, items), isScrollbarShow && /*#__PURE__*/React.createElement("div", {
+        className: "scrollbar",
+        ref: "scrollbar"
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "moveScroll",
+        style: {
+          height: scrollbarHeight,
+          top: scrollbarTop
+        },
+        onMouseDown: this._down
+      }), /*#__PURE__*/React.createElement("div", {
+        className: "moveScroll-top",
+        onClick: this._scrollTop
+      }), /*#__PURE__*/React.createElement("div", {
+        className: "moveScroll-bottom",
+        onClick: this._scrollBottom
+      }))), this.needLeftScroll && /*#__PURE__*/React.createElement("div", {
+        className: "tree-left-scroll-box",
+        ref: "leftScrollBox"
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "tree-left-scroll-ball-left",
+        onClick: this._leftScrollLeft
+      }), /*#__PURE__*/React.createElement("div", {
+        className: "tree-left-scroll-ball-right",
+        onClick: this._leftScrollRight
+      }), isScrollbarShow && /*#__PURE__*/React.createElement("div", {
+        className: "tree-left-scroll-ball-holder"
+      }), /*#__PURE__*/React.createElement("div", {
+        className: "tree-left-scroll-ball",
+        ref: "leftScrollBall",
+        onMouseDown: this._leftScrollDown
+      }))));
+    }
+  }]);
+}(Component);
+/**
+ * 渲染树节点组件
+ * @param {*} props
+ */
+Tree.propTypes = {
+  // 是否需要根节点
+  needRootNode: PropTypes.bool,
+  //是否模糊搜索，用空格隔开搜索字符
+  needFuzzySearch: PropTypes.bool,
+  treeIcon: PropTypes.func,
+  treeLoader: PropTypes.func,
+  treeNode: PropTypes.func,
+  // 请求结束需要执行的函数
+  requestFinishedFunc: PropTypes.func,
+  // 双击
+  onDoubleClick: PropTypes.func,
+  // 右键
+  onRightClick: PropTypes.func,
+  // 单击
+  onClick: PropTypes.func,
+  // 拖拽开始
+  onDragStart: PropTypes.func,
+  // 拖拽开始
+  onDragEnd: PropTypes.func,
+  // 鼠标移入事件
+  onMouseEnter: PropTypes.func,
+  // 鼠标移出事件
+  onMouseLeave: PropTypes.func,
+  // 搜索框
+  isNeedSearch: PropTypes.bool || PropTypes.string,
+  treeTitleNode: PropTypes.node,
+  hiddenResList: PropTypes.array,
+  checkResList: PropTypes.array,
+  // 数据类型
+  dataTypes: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.arrayOf(PropTypes.number)]),
+  // 标签类型
+  labelTypes: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.arrayOf(PropTypes.number)]),
+  // 显示搜索框的数据类型
+  checkboxTypes: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.number), PropTypes.number]),
+  // 勾选组织时，是否请求组织下面所有的数据(使用此属性，会下降勾选的速率)
+  isCheckAll: PropTypes.bool,
+  // 获取被勾选的节点信息
+  onCheck: PropTypes.func,
+  // 重置树的事件
+  onReset: PropTypes.func,
+  // 能否拖拽
+  canDragType: PropTypes.array,
+  // 默认加载完成 根节点被选中高亮
+  autoSelectBase: PropTypes.bool,
+  // 默认选中的资源，仅在资源可勾选有效
+  defaultSelect: PropTypes.array,
+  // 根节点数据完成可视化操作后执行周期函数
+  requestFinishdeToNodeFunc: PropTypes.func,
+  //任意树节点有请求数据返回并且完成可视化后的回调函数  this.dataObj和cameraArray修改完毕后的回调，如果请求没有返回值，我也暂定不进回调
+  nodeLoadFinishedFunc: PropTypes.func,
+  requestFailedFunc: PropTypes.func,
+  intoOrOutCity: PropTypes.string,
+  isClearAndSearch: PropTypes.bool,
+  //清空搜索框时是否同步查询
+  //选中结点后，是否进行级联操作
+  isLoopCheck: PropTypes.bool
+};
+Tree.defaultProps = {
+  needRootNode: true,
+  needFuzzySearch: false,
+  treeIcon: UTreeIcon,
+  treeLoader: UTreeLoader,
+  treeNode: UTreeNode,
+  checkboxTypes: [],
+  isNeedSearch: false,
+  treeTitleNode: undefined,
+  hiddenResList: [],
+  checkResList: [],
+  isCheckAll: false,
+  canDragType: [],
+  autoSelectBase: false,
+  defaultSelect: [],
+  intoOrOutCity: '',
+  isUseOldTree: false,
+  combineThreeCode: false,
+  isSlectCmaedd: false,
+  //用来控制VMS情况下根组织是root，不随用户组织改动
+  isShowOrgInfo: false,
+  //用来过滤VMS情况下无权限的树节点不显示
+  isPartCheckInfo: false,
+  //用来控制是否返回半选状态的组织信息
+  requestFinishdeToNodeFunc: function requestFinishdeToNodeFunc() {},
+  isLoopCheck: true,
+  nodeLoadFinishedFunc: function nodeLoadFinishedFunc() {}
+};
+export { Tree as default };
+function TreeNode(props) {
+  var value = props.value,
+    isFloder = props.isFloder,
+    isOpen = props.isOpen,
+    iconLeftClick = props.iconLeftClick,
+    needClickStyle = props.needClickStyle,
+    click = props.click,
+    rightClick = props.rightClick,
+    doubleClick = props.doubleClick,
+    needMouseEnterStyle = props.needMouseEnterStyle,
+    mouseEnter = props.mouseEnter,
+    mouseLeave = props.mouseLeave,
+    dragStart = props.dragStart,
+    dragEnd = props.dragEnd,
+    floorNum = props.floorNum,
+    iconClass = props.iconClass,
+    targetNode = props.targetNode,
+    showCheckbox = props.showCheckbox,
+    checkFunc = props.checkFunc,
+    isNeedEllipsis = props.isNeedEllipsis;
+  var _targetNode$isCheck = targetNode.isCheck,
+    isCheck = _targetNode$isCheck === void 0 ? false : _targetNode$isCheck,
+    isOrgNode = targetNode.isOrgNode,
+    loopCheck = targetNode.loopCheck,
+    isDisPlay = targetNode.isDisPlay;
+
+  /**
+   * checkbox change事件
+   * @param {*} event
+   */
+  var cbChange = function cbChange(event) {
+    checkFunc(event, event.target.checked);
+  };
+  var classFront = '';
+  if (floorNum === 1) {
+    classFront = isFloder ? isOpen ? 'fakeOut' : 'fakeIn' : 'fakeFloder';
+  } else {
+    classFront = isFloder ? isOpen ? 'minus' : 'plus' : 'fake';
+  }
+  return /*#__PURE__*/React.createElement("li", {
+    className: treePrefix + '-box-part' + floorNum + ' ' + needClickStyle + ' ' + needMouseEnterStyle,
+    onClick: click,
+    draggable: !isOrgNode ? true : false,
+    onDoubleClick: doubleClick,
+    onDragStart: dragStart,
+    onDragEnd: dragEnd,
+    onMouseEnter: mouseEnter,
+    onMouseLeave: mouseLeave
+  }, /*#__PURE__*/React.createElement("span", {
+    className: classFront,
+    type: "expand",
+    onClick: iconLeftClick
+  }), /*#__PURE__*/React.createElement("div", {
+    onContextMenu: rightClick
+  }, showCheckbox && /*#__PURE__*/React.createElement(Checkbox, {
+    onChange: cbChange,
+    checked: isCheck,
+    indeterminate: loopCheck === LOOP_CHECK_TYPE.SOME
+  }), /*#__PURE__*/React.createElement("span", {
+    className: iconClass + " ".concat(treePrefix, "-icon")
+  }), /*#__PURE__*/React.createElement("span", {
+    className: "".concat(treePrefix, "-node-desc") + (isNeedEllipsis ? " ".concat(treePrefix, "-node-desc-ellipsis") : ''),
+    title: value
+  }, value)));
+}
+
+/**
+ * 渲染树加载节点组件
+ * @param {*} props
+ */
+function LoadNode(props) {
+  return /*#__PURE__*/React.createElement("li", {
+    className: "".concat(treePrefix, "-box-part") + props.floorNum + ' tree-loadnode'
+  }, /*#__PURE__*/React.createElement("span", {
+    className: props.isSearching ? 'search-load' : 'load'
+  }), /*#__PURE__*/React.createElement("span", {
+    onClick: props.click,
+    className: "tree-load-label"
+  }, props.value));
+}