@cw-devops/bk-magic-vue/lib/tree.js

基于蓝鲸 Magicbox 和 Vue 的前端组件库

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('bk-magic-vue/lib/locale')) :
	typeof define === 'function' && define.amd ? define(['exports', 'bk-magic-vue/lib/locale'], factory) :
	(global = global || self, factory(global.library = {}, global.locale));
}(this, function (exports, locale) { 'use strict';

	locale = locale && locale.hasOwnProperty('default') ? locale['default'] : locale;

	function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
	}

	var _global = createCommonjsModule(function (module) {
	var global = module.exports = typeof window != 'undefined' && window.Math == Math
	  ? window : typeof self != 'undefined' && self.Math == Math ? self
	  : Function('return this')();
	if (typeof __g == 'number') __g = global;
	});

	var _core = createCommonjsModule(function (module) {
	var core = module.exports = { version: '2.6.12' };
	if (typeof __e == 'number') __e = core;
	});
	var _core_1 = _core.version;

	var _aFunction = function (it) {
	  if (typeof it != 'function') throw TypeError(it + ' is not a function!');
	  return it;
	};

	var _ctx = function (fn, that, length) {
	  _aFunction(fn);
	  if (that === undefined) return fn;
	  switch (length) {
	    case 1: return function (a) {
	      return fn.call(that, a);
	    };
	    case 2: return function (a, b) {
	      return fn.call(that, a, b);
	    };
	    case 3: return function (a, b, c) {
	      return fn.call(that, a, b, c);
	    };
	  }
	  return function () {
	    return fn.apply(that, arguments);
	  };
	};

	var _isObject = function (it) {
	  return typeof it === 'object' ? it !== null : typeof it === 'function';
	};

	var _anObject = function (it) {
	  if (!_isObject(it)) throw TypeError(it + ' is not an object!');
	  return it;
	};

	var _fails = function (exec) {
	  try {
	    return !!exec();
	  } catch (e) {
	    return true;
	  }
	};

	var _descriptors = !_fails(function () {
	  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
	});

	var document$1 = _global.document;
	var is = _isObject(document$1) && _isObject(document$1.createElement);
	var _domCreate = function (it) {
	  return is ? document$1.createElement(it) : {};
	};

	var _ie8DomDefine = !_descriptors && !_fails(function () {
	  return Object.defineProperty(_domCreate('div'), 'a', { get: function () { return 7; } }).a != 7;
	});

	var _toPrimitive = function (it, S) {
	  if (!_isObject(it)) return it;
	  var fn, val;
	  if (S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;
	  if (typeof (fn = it.valueOf) == 'function' && !_isObject(val = fn.call(it))) return val;
	  if (!S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;
	  throw TypeError("Can't convert object to primitive value");
	};

	var dP = Object.defineProperty;
	var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) {
	  _anObject(O);
	  P = _toPrimitive(P, true);
	  _anObject(Attributes);
	  if (_ie8DomDefine) try {
	    return dP(O, P, Attributes);
	  } catch (e) {  }
	  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
	  if ('value' in Attributes) O[P] = Attributes.value;
	  return O;
	};
	var _objectDp = {
		f: f
	};

	var _propertyDesc = function (bitmap, value) {
	  return {
	    enumerable: !(bitmap & 1),
	    configurable: !(bitmap & 2),
	    writable: !(bitmap & 4),
	    value: value
	  };
	};

	var _hide = _descriptors ? function (object, key, value) {
	  return _objectDp.f(object, key, _propertyDesc(1, value));
	} : function (object, key, value) {
	  object[key] = value;
	  return object;
	};

	var hasOwnProperty = {}.hasOwnProperty;
	var _has = function (it, key) {
	  return hasOwnProperty.call(it, key);
	};

	var PROTOTYPE = 'prototype';
	var $export = function (type, name, source) {
	  var IS_FORCED = type & $export.F;
	  var IS_GLOBAL = type & $export.G;
	  var IS_STATIC = type & $export.S;
	  var IS_PROTO = type & $export.P;
	  var IS_BIND = type & $export.B;
	  var IS_WRAP = type & $export.W;
	  var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {});
	  var expProto = exports[PROTOTYPE];
	  var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] : (_global[name] || {})[PROTOTYPE];
	  var key, own, out;
	  if (IS_GLOBAL) source = name;
	  for (key in source) {
	    own = !IS_FORCED && target && target[key] !== undefined;
	    if (own && _has(exports, key)) continue;
	    out = own ? target[key] : source[key];
	    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
	    : IS_BIND && own ? _ctx(out, _global)
	    : IS_WRAP && target[key] == out ? (function (C) {
	      var F = function (a, b, c) {
	        if (this instanceof C) {
	          switch (arguments.length) {
	            case 0: return new C();
	            case 1: return new C(a);
	            case 2: return new C(a, b);
	          } return new C(a, b, c);
	        } return C.apply(this, arguments);
	      };
	      F[PROTOTYPE] = C[PROTOTYPE];
	      return F;
	    })(out) : IS_PROTO && typeof out == 'function' ? _ctx(Function.call, out) : out;
	    if (IS_PROTO) {
	      (exports.virtual || (exports.virtual = {}))[key] = out;
	      if (type & $export.R && expProto && !expProto[key]) _hide(expProto, key, out);
	    }
	  }
	};
	$export.F = 1;
	$export.G = 2;
	$export.S = 4;
	$export.P = 8;
	$export.B = 16;
	$export.W = 32;
	$export.U = 64;
	$export.R = 128;
	var _export = $export;

	var toString = {}.toString;
	var _cof = function (it) {
	  return toString.call(it).slice(8, -1);
	};

	var _isArray = Array.isArray || function isArray(arg) {
	  return _cof(arg) == 'Array';
	};

	_export(_export.S, 'Array', { isArray: _isArray });

	var isArray = _core.Array.isArray;

	var isArray$1 = isArray;

	function _iterableToArrayLimit(r, l) {
	  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	  if (null != t) {
	    var e,
	      n,
	      i,
	      u,
	      a = [],
	      f = !0,
	      o = !1;
	    try {
	      if (i = (t = t.call(r)).next, 0 === l) {
	        if (Object(t) !== t) return;
	        f = !1;
	      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
	    } catch (r) {
	      o = !0, n = r;
	    } finally {
	      try {
	        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
	      } finally {
	        if (o) throw n;
	      }
	    }
	    return a;
	  }
	}
	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 _extends() {
	  _extends = Object.assign ? Object.assign.bind() : function (target) {
	    for (var i = 1; i < arguments.length; i++) {
	      var source = arguments[i];
	      for (var key in source) {
	        if (Object.prototype.hasOwnProperty.call(source, key)) {
	          target[key] = source[key];
	        }
	      }
	    }
	    return target;
	  };
	  return _extends.apply(this, arguments);
	}
	function _slicedToArray(arr, i) {
	  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
	}
	function _toConsumableArray(arr) {
	  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
	}
	function _arrayWithoutHoles(arr) {
	  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
	}
	function _arrayWithHoles(arr) {
	  if (Array.isArray(arr)) return arr;
	}
	function _iterableToArray(iter) {
	  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
	}
	function _unsupportedIterableToArray(o, minLen) {
	  if (!o) return;
	  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
	  var n = Object.prototype.toString.call(o).slice(8, -1);
	  if (n === "Object" && o.constructor) n = o.constructor.name;
	  if (n === "Map" || n === "Set") return Array.from(o);
	  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
	}
	function _arrayLikeToArray(arr, len) {
	  if (len == null || len > arr.length) len = arr.length;
	  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
	  return arr2;
	}
	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 _nonIterableRest() {
	  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}
	function _createForOfIteratorHelper(o, allowArrayLike) {
	  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
	  if (!it) {
	    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
	      if (it) o = it;
	      var i = 0;
	      var F = function () {};
	      return {
	        s: F,
	        n: function () {
	          if (i >= o.length) return {
	            done: true
	          };
	          return {
	            done: false,
	            value: o[i++]
	          };
	        },
	        e: function (e) {
	          throw e;
	        },
	        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 normalCompletion = true,
	    didErr = false,
	    err;
	  return {
	    s: function () {
	      it = it.call(o);
	    },
	    n: function () {
	      var step = it.next();
	      normalCompletion = step.done;
	      return step;
	    },
	    e: function (e) {
	      didErr = true;
	      err = e;
	    },
	    f: function () {
	      try {
	        if (!normalCompletion && it.return != null) it.return();
	      } finally {
	        if (didErr) throw err;
	      }
	    }
	  };
	}

	var _iobject = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
	  return _cof(it) == 'String' ? it.split('') : Object(it);
	};

	var _defined = function (it) {
	  if (it == undefined) throw TypeError("Can't call method on  " + it);
	  return it;
	};

	var _toIobject = function (it) {
	  return _iobject(_defined(it));
	};

	var ceil = Math.ceil;
	var floor = Math.floor;
	var _toInteger = function (it) {
	  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
	};

	var min = Math.min;
	var _toLength = function (it) {
	  return it > 0 ? min(_toInteger(it), 0x1fffffffffffff) : 0;
	};

	var max = Math.max;
	var min$1 = Math.min;
	var _toAbsoluteIndex = function (index, length) {
	  index = _toInteger(index);
	  return index < 0 ? max(index + length, 0) : min$1(index, length);
	};

	var _arrayIncludes = function (IS_INCLUDES) {
	  return function ($this, el, fromIndex) {
	    var O = _toIobject($this);
	    var length = _toLength(O.length);
	    var index = _toAbsoluteIndex(fromIndex, length);
	    var value;
	    if (IS_INCLUDES && el != el) while (length > index) {
	      value = O[index++];
	      if (value != value) return true;
	    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
	      if (O[index] === el) return IS_INCLUDES || index || 0;
	    } return !IS_INCLUDES && -1;
	  };
	};

	var _shared = createCommonjsModule(function (module) {
	var SHARED = '__core-js_shared__';
	var store = _global[SHARED] || (_global[SHARED] = {});
	(module.exports = function (key, value) {
	  return store[key] || (store[key] = value !== undefined ? value : {});
	})('versions', []).push({
	  version: _core.version,
	  mode:  'pure' ,
	  copyright: '© 2020 Denis Pushkarev (zloirock.ru)'
	});
	});

	var id = 0;
	var px = Math.random();
	var _uid = function (key) {
	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
	};

	var shared = _shared('keys');
	var _sharedKey = function (key) {
	  return shared[key] || (shared[key] = _uid(key));
	};

	var arrayIndexOf = _arrayIncludes(false);
	var IE_PROTO = _sharedKey('IE_PROTO');
	var _objectKeysInternal = function (object, names) {
	  var O = _toIobject(object);
	  var i = 0;
	  var result = [];
	  var key;
	  for (key in O) if (key != IE_PROTO) _has(O, key) && result.push(key);
	  while (names.length > i) if (_has(O, key = names[i++])) {
	    ~arrayIndexOf(result, key) || result.push(key);
	  }
	  return result;
	};

	var _enumBugKeys = (
	  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
	).split(',');

	var _objectKeys = Object.keys || function keys(O) {
	  return _objectKeysInternal(O, _enumBugKeys);
	};

	var f$1 = {}.propertyIsEnumerable;
	var _objectPie = {
		f: f$1
	};

	var isEnum = _objectPie.f;
	var _objectToArray = function (isEntries) {
	  return function (it) {
	    var O = _toIobject(it);
	    var keys = _objectKeys(O);
	    var length = keys.length;
	    var i = 0;
	    var result = [];
	    var key;
	    while (length > i) {
	      key = keys[i++];
	      if (!_descriptors || isEnum.call(O, key)) {
	        result.push(isEntries ? [key, O[key]] : O[key]);
	      }
	    }
	    return result;
	  };
	};

	var $entries = _objectToArray(true);
	_export(_export.S, 'Object', {
	  entries: function entries(it) {
	    return $entries(it);
	  }
	});

	var entries = _core.Object.entries;

	var entries$1 = entries;

	var Render = {
	  name: 'render',
	  functional: true,
	  props: {
	    node: Object,
	    tpl: Function
	  },
	  render: function render(h, ct) {
	    var titleClass = ct.props.node.selected ? 'node-title node-selected' : 'node-title';
	    if (ct.props.tpl) {
	      return ct.props.tpl(ct.props.node, h);
	    }
	    return h("span", {
	      "domProps": {
	        "innerHTML": ct.props.node.name
	      },
	      "attrs": {
	        "title": ct.props.node.title
	      },
	      "class": titleClass,
	      "style": 'user-select: none',
	      "on": {
	        "click": function click() {
	          return ct.parent.nodeSelected(ct.props.node);
	        }
	      }
	    });
	  }
	};

	var requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (callback) {
	  window.setTimeout(callback, 1000 / 60);
	};
	var cancelAnimationFrame = window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame || function (id) {
	  window.clearTimeout(id);
	};
	var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
	var MOZ_HACK_REGEXP = /^moz([A-Z])/;
	var trim = function trim(string) {
	  return (string || '').replace(/^[\s\uFEFF]+|[\s\uFEFF]+$/g, '');
	};
	var camelCase = function camelCase(name) {
	  return name.replace(SPECIAL_CHARS_REGEXP, function (_, separator, letter, offset) {
	    return offset ? letter.toUpperCase() : letter;
	  }).replace(MOZ_HACK_REGEXP, 'Moz$1');
	};
	function hasClass(el, cls) {
	  if (!el || !cls) return false;
	  if (cls.indexOf(' ') !== -1) throw new Error('className should not contain space.');
	  if (el.classList) {
	    return el.classList.contains(cls);
	  } else {
	    return (' ' + el.className + ' ').indexOf(' ' + cls + ' ') > -1;
	  }
	}
	function addClass(el, cls) {
	  if (!el) return;
	  var curClass = el.className;
	  var classes = (cls || '').split(' ');
	  for (var i = 0, j = classes.length; i < j; i++) {
	    var clsName = classes[i];
	    if (!clsName) continue;
	    if (el.classList) {
	      el.classList.add(clsName);
	    } else if (!hasClass(el, clsName)) {
	      curClass += ' ' + clsName;
	    }
	  }
	  if (!el.classList) {
	    el.className = curClass;
	  }
	}
	function removeClass(el, cls) {
	  if (!el || !cls) return;
	  var classes = cls.split(' ');
	  var curClass = ' ' + el.className + ' ';
	  for (var i = 0, j = classes.length; i < j; i++) {
	    var clsName = classes[i];
	    if (!clsName) continue;
	    if (el.classList) {
	      el.classList.remove(clsName);
	    } else if (hasClass(el, clsName)) {
	      curClass = curClass.replace(' ' + clsName + ' ', ' ');
	    }
	  }
	  if (!el.classList) {
	    el.className = trim(curClass);
	  }
	}
	var getStyle = Number(document.documentMode) < 9 ? function (element, styleName) {
	  if (!element || !styleName) return null;
	  styleName = camelCase(styleName);
	  if (styleName === 'float') {
	    styleName = 'styleFloat';
	  }
	  try {
	    switch (styleName) {
	      case 'opacity':
	        try {
	          return element.filters.item('alpha').opacity / 100;
	        } catch (e) {
	          return 1.0;
	        }
	      default:
	        return element.style[styleName] || element.currentStyle ? element.currentStyle[styleName] : null;
	    }
	  } catch (e) {
	    return element.style[styleName];
	  }
	} : function (element, styleName) {
	  if (!element || !styleName) return null;
	  styleName = camelCase(styleName);
	  if (styleName === 'float') {
	    styleName = 'cssFloat';
	  }
	  try {
	    var computed = document.defaultView.getComputedStyle(element, '');
	    return element.style[styleName] || computed ? computed[styleName] : null;
	  } catch (e) {
	    return element.style[styleName];
	  }
	};

	var transition = {
	  beforeEnter: function beforeEnter(el) {
	    addClass(el, 'collapse-transition');
	    if (!el.dataset) {
	      el.dataset = {};
	    }
	    el.dataset.oldPaddingTop = el.style.paddingTop;
	    el.dataset.oldPaddingBottom = el.style.paddingBottom;
	    el.style.height = '0';
	    el.style.paddingTop = 0;
	    el.style.paddingBottom = 0;
	  },
	  enter: function enter(el) {
	    el.dataset.oldOverflow = el.style.overflow;
	    if (el.scrollHeight !== 0) {
	      el.style.height = el.scrollHeight + 'px';
	      el.style.paddingTop = el.dataset.oldPaddingTop;
	      el.style.paddingBottom = el.dataset.oldPaddingBottom;
	    } else {
	      el.style.height = '';
	      el.style.paddingTop = el.dataset.oldPaddingTop;
	      el.style.paddingBottom = el.dataset.oldPaddingBottom;
	    }
	    el.style.overflow = 'hidden';
	  },
	  afterEnter: function afterEnter(el) {
	    removeClass(el, 'collapse-transition');
	    el.style.height = '';
	    el.style.overflow = el.dataset.oldOverflow;
	  },
	  beforeLeave: function beforeLeave(el) {
	    if (!el.dataset) el.dataset = {};
	    el.dataset.oldPaddingTop = el.style.paddingTop;
	    el.dataset.oldPaddingBottom = el.style.paddingBottom;
	    el.dataset.oldOverflow = el.style.overflow;
	    el.style.height = el.scrollHeight + 'px';
	    el.style.overflow = 'hidden';
	  },
	  leave: function leave(el) {
	    if (el.scrollHeight !== 0) {
	      addClass(el, 'collapse-transition');
	      el.style.height = 0;
	      el.style.paddingTop = 0;
	      el.style.paddingBottom = 0;
	    }
	  },
	  afterLeave: function afterLeave(el) {
	    removeClass(el, 'collapse-transition');
	    el.style.height = '';
	    el.style.overflow = el.dataset.oldOverflow;
	    el.style.paddingTop = el.dataset.oldPaddingTop;
	    el.style.paddingBottom = el.dataset.oldPaddingBottom;
	  }
	};
	var CollapseTransition = {
	  name: 'CollapseTransition',
	  functional: true,
	  render: function render(h, _ref) {
	    var children = _ref.children;
	    var data = {
	      on: transition
	    };
	    return h('transition', data, children);
	  }
	};

	var script = {
	  name: 'bk-tree',
	  components: {
	    Render: Render,
	    CollapseTransition: CollapseTransition
	  },
	  mixins: [locale.mixin],
	  props: {
	    data: {
	      type: Array,
	      default: function _default() {
	        return [];
	      }
	    },
	    parent: {
	      type: Object,
	      default: function _default() {
	        return null;
	      }
	    },
	    multiple: {
	      type: Boolean,
	      default: false
	    },
	    nodeKey: {
	      type: String,
	      default: 'id'
	    },
	    draggable: {
	      type: Boolean,
	      default: false
	    },
	    hasBorder: {
	      type: Boolean,
	      default: false
	    },
	    dragAfterExpanded: {
	      type: Boolean,
	      default: true
	    },
	    isDeleteRoot: {
	      type: Boolean,
	      default: false
	    },
	    emptyText: {
	      type: String,
	      default: ''
	    },
	    dragSort: {
	      type: Boolean,
	      default: false
	    },
	    openedIcon: {
	      type: String,
	      default: 'icon-folder-open'
	    },
	    closedIcon: {
	      type: String,
	      default: 'icon-folder'
	    },
	    nodeIcon: {
	      type: String,
	      default: 'icon-file'
	    },
	    showIcon: {
	      type: Boolean,
	      default: true
	    },
	    tpl: Function,
	    extCls: {
	      type: String,
	      default: ''
	    }
	  },
	  data: function data() {
	    return {
	      halfcheck: true,
	      isBorder: this.hasBorder,
	      bkTreeDrag: {},
	      isDragSort: this.dragSort,
	      isShowIcon: this.showIcon
	    };
	  },
	  computed: {
	    shownData: function shownData() {
	      return this.data.filter(function (item) {
	        return item.hasOwnProperty('visible') ? item.visible : true;
	      });
	    }
	  },
	  watch: {
	    data: function data() {
	      this.initTreeData();
	    },
	    hasBorder: function hasBorder(value) {
	      this.isBorder = !!value;
	    },
	    dragSort: function dragSort(value) {
	      this.isDragSort = !!value;
	    },
	    showIcon: function showIcon(value) {
	      this.isShowIcon = !!value;
	    }
	  },
	  mounted: function mounted() {
	    var _this = this;
	    this.$on('childChecked', function (node, checked) {
	      if (node.children && node.children.length) {
	        var _iterator = _createForOfIteratorHelper(node.children),
	          _step;
	        try {
	          for (_iterator.s(); !(_step = _iterator.n()).done;) {
	            var child = _step.value;
	            if (!child.disabled) {
	              _this.$set(child, 'checked', checked);
	            }
	            _this.$emit('on-broadcast-check', child, checked);
	          }
	        } catch (err) {
	          _iterator.e(err);
	        } finally {
	          _iterator.f();
	        }
	      }
	    });
	    this.$on('parentChecked', function (node, checked) {
	      if (!node.parent) {
	        var allChildNodeChecked = node.children.every(function (node) {
	          return node.checked;
	        });
	        var someChildNodeChecked = (node.children.some(function (node) {
	          return node.halfcheck;
	        }) || node.children.some(function (node) {
	          return node.checked;
	        })) && !allChildNodeChecked;
	        if (_this.halfcheck) {
	          if (!node.disabled) {
	            _this.$set(node, 'checked', allChildNodeChecked);
	            _this.$set(node, 'halfcheck', someChildNodeChecked);
	          }
	        }
	        return false;
	      }
	      if (!node.parent.children.filter(function (child) {
	        return child[_this.nodeKey] === node[_this.nodeKey];
	      }).length && !node.disabled) {
	        _this.$set(node, 'checked', checked);
	      }
	      var allBortherNodeChecked = node.parent.children.every(function (node) {
	        return node.checked;
	      });
	      var someBortherNodeChecked = (node.parent.children.some(function (node) {
	        return node.halfcheck;
	      }) || node.parent.children.some(function (node) {
	        return node.checked;
	      })) && !allBortherNodeChecked;
	      if (_this.halfcheck) {
	        if (allBortherNodeChecked) {
	          _this.$set(node.parent, 'halfcheck', false);
	          _this.$set(node.parent, 'checked', true);
	        } else {
	          if (someBortherNodeChecked) {
	            _this.$set(node.parent, 'halfcheck', true);
	            _this.$set(node.parent, 'checked', false);
	          } else {
	            _this.$set(node.parent, 'halfcheck', false);
	            _this.$set(node.parent, 'checked', false);
	          }
	        }
	        if (!checked && someBortherNodeChecked) {
	          _this.$set(node.parent, 'halfcheck', true);
	        }
	        _this.$emit('parentChecked', node.parent, checked);
	      } else {
	        if (checked && allBortherNodeChecked) _this.$emit('parentChecked', node.parent, checked);
	        if (!checked) _this.$emit('parentChecked', node.parent, checked);
	      }
	    });
	    this.$on('on-broadcast-check', function (node, checked) {
	      if (!node.parent && !node.children) {
	        return;
	      }
	      _this.$emit('parentChecked', node, checked);
	      _this.$emit('childChecked', node, checked);
	      _this.$emit('dropTreeChecked', node, checked);
	    });
	    this.$on('toggleshow', function (node, isShow) {
	      _this.$set(node, 'visible', isShow);
	      if (isShow && node.parent) {
	        _this.$emit('toggleshow', node.parent, isShow);
	      }
	    });
	    this.$on('cancelSelected', function (root) {
	      var _iterator2 = _createForOfIteratorHelper(root.$children),
	        _step2;
	      try {
	        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
	          var child = _step2.value;
	          var _iterator3 = _createForOfIteratorHelper(child.data),
	            _step3;
	          try {
	            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
	              var node = _step3.value;
	              child.$set(node, 'selected', false);
	            }
	          } catch (err) {
	            _iterator3.e(err);
	          } finally {
	            _iterator3.f();
	          }
	          if (child.$children) child.$emit('cancelSelected', child);
	        }
	      } catch (err) {
	        _iterator2.e(err);
	      } finally {
	        _iterator2.f();
	      }
	    });
	    this.initTreeData();
	  },
	  destroyed: function destroyed() {
	    this.$delete(window, 'bkTreeDrag');
	  },
	  methods: {
	    gid: function gid() {
	      return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
	        var r = Math.random() * 16 | 0;
	        var v = c === 'x' ? r : r & 0x3 | 0x8;
	        return v.toString(16);
	      });
	    },
	    setDragNode: function setDragNode(id, node) {
	      window['bkTreeDrag'] = {};
	      window['bkTreeDrag'][id] = node;
	    },
	    getDragNode: function getDragNode(id) {
	      return window['bkTreeDrag'][id];
	    },
	    hasInGenerations: function hasInGenerations(root, node) {
	      if (root.hasOwnProperty('children') && root.children) {
	        var _iterator4 = _createForOfIteratorHelper(root.children),
	          _step4;
	        try {
	          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
	            var rn = _step4.value;
	            if (rn === node) return true;
	            if (rn.children) return this.hasInGenerations(rn, node);
	          }
	        } catch (err) {
	          _iterator4.e(err);
	        } finally {
	          _iterator4.f();
	        }
	        return false;
	      }
	    },
	    isDragSortHolder: function isDragSortHolder(target, node) {
	      if (target.hasOwnProperty('children') && target.children) {
	        var _iterator5 = _createForOfIteratorHelper(target.children),
	          _step5;
	        try {
	          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
	            var rn = _step5.value;
	            if (rn[this.nodeKey] === node[this.nodeKey]) return false;
	            if (rn.children) return this.isDragSortHolder(rn, node);
	          }
	        } catch (err) {
	          _iterator5.e(err);
	        } finally {
	          _iterator5.f();
	        }
	        return true;
	      }
	    },
	    setNodeIcon: function setNodeIcon(node) {
	      if (node.children && node.children.length) {
	        if (node.expanded) {
	          return node.openedIcon || this.openedIcon;
	        } else {
	          return node.closedIcon || this.closedIcon;
	        }
	      } else {
	        return node.icon || this.nodeIcon;
	      }
	    },
	    drop: function drop(node, ev) {
	      var _this2 = this;
	      ev.preventDefault();
	      ev.stopPropagation();
	      if (!this.draggable) {
	        return;
	      }
	      var gid = ev.dataTransfer.getData('gid');
	      var drag = this.getDragNode(gid);
	      if (drag.parent === node || drag.parent === null || drag === node) {
	        return false;
	      }
	      if (this.hasInGenerations(drag, node)) {
	        return false;
	      }
	      if (this.isDragSort) {
	        if ([true, false].includes(this.isDragSortHolder(node, drag))) {
	          if (!this.isDragSortHolder(node, drag)) {
	            return false;
	          }
	        }
	        var dragNodeIndex = drag.parent.children.findIndex(function (dragItem) {
	          return dragItem[_this2.nodeKey] === drag[_this2.nodeKey];
	        });
	        var targetNodeIndex = node.parent.children.findIndex(function (targetItem) {
	          return targetItem[_this2.nodeKey] === node[_this2.nodeKey];
	        });
	        drag.parent.children.splice(dragNodeIndex, 1, node);
	        node.parent.children.splice(targetNodeIndex, 1, drag);
	        node.parent.children[targetNodeIndex].parent = drag.parent;
	        if (this.multiple) {
	          this.$emit('on-broadcast-check', drag, drag.checked);
	        }
	        drag.parent.children[dragNodeIndex].parent = node.parent;
	        if (this.multiple) {
	          this.$emit('on-broadcast-check', node, node.checked);
	        }
	      } else {
	        var dragHost = drag.parent.children;
	        if (node.children && node.children.indexOf(drag) === -1) {
	          node.children.push(drag);
	          if (node.children.length && this.isShowIcon) {
	            this.$set(node, 'openedIcon', this.openedIcon);
	            this.$set(node, 'closedIcon', this.closedIcon);
	          }
	          dragHost.splice(dragHost.indexOf(drag), 1);
	          if (this.isShowIcon) {
	            if (drag.parent.children && drag.parent.children.length) {
	              this.$set(drag.parent, 'openedIcon', this.openedIcon);
	              this.$set(drag.parent, 'closedIcon', this.closedIcon);
	            } else {
	              this.$set(drag.parent, 'icon', this.nodeIcon);
	            }
	          }
	          node.children[node.children.length - 1].parent = node;
	        } else {
	          if (this.isShowIcon) {
	            this.$set(node, 'openedIcon', this.openedIcon);
	            this.$set(node, 'closedIcon', this.closedIcon);
	          }
	          this.$set(node, 'children', [drag]);
	          dragHost.splice(dragHost.indexOf(drag), 1);
	        }
	        this.$set(node, 'expanded', this.dragAfterExpanded);
	      }
	      this.$emit('on-drag-node', {
	        dragNode: drag,
	        targetNode: node
	      });
	    },
	    drag: function drag(node, ev) {
	      var gid = this.gid();
	      this.setDragNode(gid, node);
	      ev.dataTransfer.setData('gid', gid);
	      ev.dataTransfer.effectAllowed = 'move';
	    },
	    dragover: function dragover(ev) {
	      ev.preventDefault();
	      ev.stopPropagation();
	    },
	    initTreeData: function initTreeData() {
	      var _iterator6 = _createForOfIteratorHelper(this.data),
	        _step6;
	      try {
	        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
	          var node = _step6.value;
	          this.$set(node, 'parent', this.parent);
	          if (node.children && node.children.length) {
	            if (node.hasOwnProperty('icon')) {
	              this.$delete(node, 'icon');
	            }
	          } else {
	            if (node.hasOwnProperty('openedIcon')) {
	              this.$delete(node, 'openedIcon');
	            }
	            if (node.hasOwnProperty('closedIcon')) {
	              this.$delete(node, 'closedIcon');
	            }
	          }
	          if (this.multiple) {
	            if (node.hasOwnProperty('selected')) {
	              this.$delete(node, 'selected');
	            }
	            if (node.hasOwnProperty('checked') && node.checked) {
	              this.$emit('on-broadcast-check', node, true);
	            }
	          } else {
	            if (node.hasOwnProperty('checked')) {
	              this.$delete(node, 'checked');
	            }
	          }
	        }
	      } catch (err) {
	        _iterator6.e(err);
	      } finally {
	        _iterator6.f();
	      }
	    },
	    expandNode: function expandNode(node) {
	      this.$set(node, 'expanded', !node.expanded);
	      if (node.async && !node.children) {
	        this.$emit('async-load-nodes', node);
	      }
	      if (node.children && node.children.length) {
	        this.$emit('on-expanded', node, node.expanded);
	      }
	    },
	    onExpanded: function onExpanded(node) {
	      if (node.children && node.children.length) {
	        this.$emit('on-expanded', node, node.expanded);
	      }
	    },
	    triggerExpand: function triggerExpand(item) {
	      if (!item.parent || item.children && item.children.length || item.async) {
	        this.expandNode(item);
	      }
	    },
	    asyncLoadNodes: function asyncLoadNodes(node) {
	      if (node.async && !node.children) {
	        this.$emit('async-load-nodes', node);
	      }
	    },
	    isLeaf: function isLeaf(node) {
	      return !(node.children && node.children.length) && node.parent && !node.async;
	    },
	    addNode: function addNode(parent, newNode) {
	      var addnode = {};
	      this.$set(parent, 'expanded', true);
	      if (typeof newNode === 'undefined') {
	        throw new ReferenceError('newNode is required but undefined');
	      }
	      if (_typeof(newNode) === 'object' && !newNode.hasOwnProperty('name')) {
	        throw new ReferenceError('the name property is missed');
	      }
	      if (_typeof(newNode) === 'object' && !newNode.hasOwnProperty(this.nodeKey)) {
	        throw new ReferenceError('the nodeKey property is missed');
	      }
	      if (_typeof(newNode) === 'object' && newNode.hasOwnProperty('name') && newNode.hasOwnProperty(this.nodeKey)) {
	        addnode = _extends({}, newNode);
	      }
	      if (this.isLeaf(parent)) {
	        this.$set(parent, 'children', []);
	        parent.children.push(addnode);
	      } else {
	        parent.children.push(addnode);
	      }
	      this.$emit('addNode', {
	        parentNode: parent,
	        newNode: newNode
	      });
	    },
	    addNodes: function addNodes(parent, newChildren) {
	      var _iterator7 = _createForOfIteratorHelper(newChildren),
	        _step7;
	      try {
	        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
	          var n = _step7.value;
	          this.addNode(parent, n);
	        }
	      } catch (err) {
	        _iterator7.e(err);
	      } finally {
	        _iterator7.f();
	      }
	    },
	    getSearchResult: function getSearchResult() {
	      var list = [];
	      for (var i = 0; i < this.data.length; i++) {
	        var queue = [];
	        queue.push(this.data[i]);
	        while (queue.length) {
	          var node = queue.shift();
	          if (node.children && node.children.length) {
	            var tempList = [];
	            tempList.splice.apply(tempList, [0, 0].concat(_toConsumableArray(node.children)));
	            queue.push.apply(queue, tempList);
	          }
	          list.push(node);
	        }
	      }
	      return {
	        results: list.filter(function (item) {
	          return item.hasOwnProperty('visible') && item.visible;
	        }),
	        isEmpty: list.every(function (item) {
	          return item.hasOwnProperty('visible') && !item.visible;
	        })
	      };
	    },
	    onClick: function onClick(node) {
	      this.$emit('on-click', node);
	    },
	    onCheck: function onCheck(node, checked) {
	      this.$emit('on-check', node, checked);
	    },
	    onBroadcastCheck: function onBroadcastCheck(node, checked) {
	      this.$emit('on-broadcast-check', node, checked);
	    },
	    nodeCheckStatusChange: function nodeCheckStatusChange(node, checked) {
	      this.$emit('dropTreeChecked', node, checked);
	    },
	    onDragNode: function onDragNode(event) {
	      this.$emit('on-drag-node', event);
	    },
	    delNode: function delNode(parent, node) {
	      if (parent === null || typeof parent === 'undefined') {
	        if (this.isDeleteRoot) {
	          this.data.splice(0, 1);
	        } else {
	          throw new ReferenceError('the root element can\'t deleted!');
	        }
	      } else {
	        parent.children.splice(parent.children.indexOf(node), 1);
	      }
	      this.$emit('delNode', {
	        parentNode: parent,
	        delNode: node
	      });
	    },
	    changeCheckStatus: function changeCheckStatus(node, $event) {
	      this.$emit('on-check', node, $event.target.checked);
	      this.$emit('on-broadcast-check', node, $event.target.checked);
	    },
	    nodeSelected: function nodeSelected(node) {
	      var getRoot = function getRoot(el) {
	        if (el.$parent.$el.nodeName === 'UL') {
	          el = el.$parent;
	          return getRoot(el);
	        }
	        return el;
	      };
	      var root = getRoot(this);
	      if (!this.multiple) {
	        var _iterator8 = _createForOfIteratorHelper(root.data || []),
	          _step8;
	        try {
	          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
	            var rn = _step8.value;
	            this.$set(rn, 'selected', false);
	            this.$emit('cancelSelected', root);
	          }
	        } catch (err) {
	          _iterator8.e(err);
	        } finally {
	          _iterator8.f();
	        }
	      }
	      this.$set(node, 'selected', !node.selected);
	      this.$emit('on-click', node);
	    },
	    nodeDataHandler: function nodeDataHandler(opt, data, keyParton) {
	      data = data || this.data;
	      var res = [];
	      var keyValue = keyParton;
	      var _iterator9 = _createForOfIteratorHelper(data),
	        _step9;
	      try {
	        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
	          var node = _step9.value;
	          for (var _i = 0, _Object$entries = entries$1(opt); _i < _Object$entries.length; _i++) {
	            var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
	              key = _Object$entries$_i[0],
	              value = _Object$entries$_i[1];
	            if (node[key] === value) {
	              if (!keyValue.length || !keyValue) {
	                var n = _extends({}, node);
	                delete n['parent'];
	                if (!(n.children && n.children.length)) {
	                  res.push(n);
	                }
	              } else {
	                var _n = {};
	                if (Object.prototype.toString.call(keyValue) === '[object Array]') {
	                  for (var i = 0; i < keyValue.length; i++) {
	                    if (node.hasOwnProperty(keyValue[i])) {
	                      _n[keyValue[i]] = node[keyValue[i]];
	                    }
	                  }
	                }
	                if (Object.prototype.toString.call(keyValue) === '[object String]') {
	                  _n[keyValue] = node[keyValue];
	                }
	                if (!(node.children && node.children.length)) {
	                  res.push(_n);
	                }
	              }
	            }
	          }
	          if (node.children && node.children.length) {
	            res = res.concat(this.nodeDataHandler(opt, node.children, keyValue));
	          }
	        }
	      } catch (err) {
	        _iterator9.e(err);
	      } finally {
	        _iterator9.f();
	      }
	      return res;
	    },
	    getNode: function getNode(keyParton) {
	      if (!this.multiple) {
	        return this.nodeDataHandler({
	          selected: true
	        }, this.data, keyParton);
	      } else {
	        return this.nodeDataHandler({
	          checked: true
	        }, this.data, keyParton);
	      }
	    },
	    searchNode: function searchNode(filter, data) {
	      data = data || this.data;
	      var _iterator10 = _createForOfIteratorHelper(data),
	        _step10;
	      try {
	        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
	          var node = _step10.value;
	          var searched = filter ? typeof filter === 'function' ? filter(node) : node['name'].indexOf(filter) > -1 : false;
	          this.$set(node, 'searched', searched);
	          this.$set(node, 'visible', false);
	          this.$emit('toggleshow', node, filter ? searched : true);
	          if (node.children && node.children.length) {
	            if (searched) {
	              this.$set(node, 'expanded', true);
	            }
	            this.searchNode(filter, node.children);
	          }
	        }
	      } catch (err) {
	        _iterator10.e(err);
	      } finally {
	        _iterator10.f();
	      }
	    }
	  }
	};

	function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier
	, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
	  if (typeof shadowMode !== 'boolean') {
	    createInjectorSSR = createInjector;
	    createInjector = shadowMode;
	    shadowMode = false;
	  }
	  var options = typeof script === 'function' ? script.options : script;
	  if (template && template.render) {
	    options.render = template.render;
	    options.staticRenderFns = template.staticRenderFns;
	    options._compiled = true;
	    if (isFunctionalTemplate) {
	      options.functional = true;
	    }
	  }
	  if (scopeId) {
	    options._scopeId = scopeId;
	  }
	  var hook;
	  if (moduleIdentifier) {
	    hook = function hook(context) {
	      context = context ||
	      this.$vnode && this.$vnode.ssrContext ||
	      this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext;
	      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
	        context = __VUE_SSR_CONTEXT__;
	      }
	      if (style) {
	        style.call(this, createInjectorSSR(context));
	      }
	      if (context && context._registeredComponents) {
	        context._registeredComponents.add(moduleIdentifier);
	      }
	    };
	    options._ssrRegister = hook;
	  } else if (style) {
	    hook = shadowMode ? function () {
	      style.call(this, createInjectorShadow(this.$root.$options.shadowRoot));
	    } : function (context) {
	      style.call(this, createInjector(context));
	    };
	  }
	  if (hook) {
	    if (options.functional) {
	      var originalRender = options.render;
	      options.render = function renderWithStyleInjection(h, context) {
	        hook.call(context);
	        return originalRender(h, context);
	      };
	    } else {
	      var existing = options.beforeCreate;
	      options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
	    }
	  }
	  return script;
	}
	var normalizeComponent_1 = normalizeComponent;

	var __vue_script__ = script;
	/* template */
	var __vue_render__ = function __vue_render__() {
	  var _vm = this;
	  var _h = _vm.$createElement;
	  var _c = _vm._self._c || _h;
	  return _c('ul', {
	    staticClass: "bk-tree",
	    class: [{
	      'bk-has-border-tree': _vm.isBorder
	    }, _vm.extCls]
	  }, _vm._l(_vm.shownData, function (item, index) {
	    return _c('li', {
	      key: item[_vm.nodeKey] ? item[_vm.nodeKey] : item.name,
	      class: {
	        'leaf': _vm.isLeaf(item),
	        'tree-first-node': !_vm.parent && index === 0,
	        'tree-only-node': !_vm.parent && _vm.shownData.length === 1,
	        'tree-second-node': !_vm.parent && index === 1,
	        'single': !_vm.multiple
	      },
	      on: {
	        "drop": function drop($event) {
	          _vm.drop(item, $event);
	        },
	        "dragover": function dragover($event) {
	          _vm.dragover($event);
	        }
	      }
	    }, [_c('div', {
	      staticClass: "tree-drag-node",
	      attrs: {
	        "draggable": _vm.draggable
	      },
	      on: {
	        "dragstart": function dragstart($event) {
	          _vm.drag(item, $event);
	        }
	      }
	    }, [!item.parent || item.children && item.children.length || item.async ? _c('span', {
	      class: ['bk-icon', 'tree-expanded-icon', item.expanded ? 'icon-down-shape' : 'icon-right-shape'],
	      on: {
	        "click": function click($event) {
	          _vm.expandNode(item);
	        }
	      }
	    }) : _vm._e(), _vm.multiple ? _c('label', {
	      class: ['bk-form-checkbox', {
	        'bk-form-checkbox--indeterminate': item.halfcheck
	      }, {
	        'bk-form-checkbox--checked': item.checked
	      }, {
	        'bk-form-checkbox--disabled': item.disabled
	      }]
	    }, [_vm.multiple ? _c('input', {
	      directives: [{
	        name: "model",
	        rawName: "v-model",
	        value: item.checked,
	        expression: "item.checked"
	      }],
	      attrs: {
	        "type": "checkbox",
	        "disabled": item.disabled
	      },
	      domProps: {
	        "checked": isArray$1(item.checked) ? _vm._i(item.checked, null) > -1 : item.checked
	      },
	      on: {
	        "change": [function ($event) {
	          var $$a = item.checked,
	            $$el = $event.target,
	            $$c = $$el.checked ? true : false;
	          if (isArray$1($$a)) {
	            var $$v = null,
	              $$i = _vm._i($$a, $$v);
	            if ($$el.checked) {
	              $$i < 0 && _vm.$set(item, "checked", $$a.concat([$$v]));
	            } else {
	              $$i > -1 && _vm.$set(item, "checked", $$a.slice(0, $$i).concat($$a.slice($$i + 1)));
	            }
	          } else {
	            _vm.$set(item, "checked", $$c);
	          }
	        }, function ($event) {
	          $event.stopPropagation();
	          _vm.changeCheckStatus(item, $event);
	        }]
	      }
	    }) : _vm._e()]) : _vm._e(), _c('div', {
	      staticClass: "tree-node",
	      on: {
	        "click": function click($event) {
	          _vm.triggerExpand(item);
	        }
	      }
	    }, [_vm.isShowIcon ? _c('span', {
	      staticClass: "node-icon"
	    }, [_c('i', {
	      staticClass: "bk-icon",
	      class: _vm.setNodeIcon(item)
	    })]) : _vm._e(), item.loading && item.expanded ? _c('div', {
	      staticClass: "bk-spin-loading bk-spin-loading-mini bk-spin-loading-primary loading"
	    }, [_c('div', {
	      staticClass: "rotate rotate1"
	    }), _c('div', {
	      staticClass: "rotate rotate2"
	    }), _c('div', {
	      staticClass: "rotate rotate3"
	    }), _c('div', {
	      staticClass: "rotate rotate4"
	    }), _c('div', {
	      staticClass: "rotate rotate5"
	    }), _c('div', {
	      staticClass: "rotate rotate6"
	    }), _c('div', {
	      staticClass: "rotate rotate7"
	    }), _c('div', {
	      staticClass: "rotate rotate8"
	    })]) : _vm._e(), _c('Render', {
	      attrs: {
	        "node": item,
	        "tpl": _vm.tpl
	      }
	    })], 1)]), _c('collapse-transition', [!_vm.isLeaf(item) ? _c('bk-tree', {
	      directives: [{
	        name: "show",
	        rawName: "v-show",
	        value: item.expanded,
	        expression: "item.expanded"
	      }],
	      attrs: {
	        "drag-after-expanded": _vm.dragAfterExpanded,
	        "draggable": _vm.draggable,
	        "drag-sort": _vm.dragSort,
	        "tpl": _vm.tpl,
	        "data": item.children,
	        "halfcheck": _vm.halfcheck,
	        "parent": item,
	        "is-delete-root": _vm.isDeleteRoot,
	        "multiple": _vm.multiple,
	        "show-icon": _vm.showIcon
	      },
	      on: {
	        "dropTreeChecked": _vm.nodeCheckStatusChange,
	        "async-load-nodes": _vm.asyncLoadNodes,
	        "on-expanded": _vm.onExpanded,
	        "on-click": _vm.onClick,
	        "on-check": _vm.onCheck,
	        "on-broadcast-check": _vm.onBroadcastCheck,
	        "on-drag-node": _vm.onDragNode
	      }
	    }) : _vm._e()], 1)], 1);
	  }), 0);
	};
	var __vue_staticRenderFns__ = [];

	/* style */
	var __vue_inject_styles__ = undefined;
	/* scoped */
	var __vue_scope_id__ = undefined;
	/* module identifier */
	var __vue_module_identifier__ = undefined;
	/* functional template */
	var __vue_is_functional_template__ = false;
	/* style inject */

	/* style inject SSR */

	/* style inject shadow dom */

	var __vue_component__ = /*#__PURE__*/normalizeComponent_1({
	  render: __vue_render__,
	  staticRenderFns: __vue_staticRenderFns__
	}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, false, undefined, undefined, undefined);

	var _toObject = function (it) {
	  return Object(_defined(it));
	};

	var _objectSap = function (KEY, exec) {
	  var fn = (_core.Object || {})[KEY] || Object[KEY];
	  var exp = {};
	  exp[KEY] = exec(fn);
	  _export(_export.S + _export.F * _fails(function () { fn(1); }), 'Object', exp);
	};

	_objectSap('keys', function () {
	  return function keys(it) {
	    return _objectKeys(_toObject(it));
	  };
	});

	var keys = _core.Object.keys;

	var keys$1 = keys;

	function setInstaller (component, afterInstall) {
	  component.install = function (Vue) {
	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    var props = component.props || {};
	    keys$1(options).forEach(function (key) {
	      if (props.hasOwnProperty(key)) {
	        if (typeof props[key] === 'function' || props[key] instanceof Array) {
	          props[key] = {
	            type: props[key],
	            default: options[key]
	          };
	        } else {
	          props[key].default = options[key];
	        }
	      }
	    });
	    component.name = options.namespace ? component.name.replace('bk', options.namespace) : component.name;
	    Vue.component(component.name, component);
	    typeof afterInstall === 'function' && afterInstall(Vue, options);
	  };
	}

	setInsta