@mdsfe/mds-ui 0.2.0

package/dist/_util/tree/tree.js

@@ -0,0 +1,410 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _getIterator2 = require('babel-runtime/core-js/get-iterator');
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _map = require('babel-runtime/core-js/map');
+
+var _map2 = _interopRequireDefault(_map);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Tree = function () {
+  function Tree(options) {
+    var _this = this;
+
+    (0, _classCallCheck3.default)(this, Tree);
+
+    for (var name in options) {
+      if (options.hasOwnProperty(name)) {
+        this[name] = options[name];
+      }
+    }
+    if (!this.prop || (0, _typeof3.default)(this.prop) !== 'object') {
+      this.prop = {
+        label: 'label',
+        key: 'key',
+        isLeaf: 'isLeaf',
+        disabled: 'disabled',
+        children: 'children'
+      };
+    }
+
+    this.nodesMap = new _map2.default();
+    this.root = new _node2.default({
+      data: this.data,
+      tree: this
+    });
+
+    // 根据load函数渲染根节点
+    if (this.load) {
+      this.load(this.root, function (arr) {
+        if (!Array.isArray(arr)) {
+          throw new Error('传入子元素必须是数组');
+        }
+        arr.forEach(function (item) {
+          _this.root.appendChild(item);
+        });
+      });
+    }
+  }
+
+  Tree.prototype.setData = function setData(newVal) {
+    var dataChange = newVal !== this.root.data;
+    if (dataChange) {
+      this.nodesMap = new _map2.default();
+      this.root = new _node2.default({
+        data: newVal,
+        tree: this
+      });
+    }
+  };
+
+  Tree.prototype.handleSelectedChange = function handleSelectedChange(key) {
+    var selectedNode = this.nodesMap.get(key);
+    if (!selectedNode.selected) {
+      this.nodesMap.forEach(function (node, nodeKey) {
+        node.selected = false;
+        if (nodeKey === key) {
+          node.selected = true;
+        }
+      });
+      this.$tree.$emit('node-selected-change', selectedNode.data, selectedNode, selectedNode.getPath(), selectedNode.getPath(true));
+    }
+  };
+
+  Tree.prototype.handleDefaultCheckedKeys = function handleDefaultCheckedKeys() {
+    var _this2 = this;
+
+    // 处理defaultCheckedKeys
+    if (this.defaultCheckedKeys) {
+      this.defaultCheckedKeys.forEach(function (item) {
+        _this2.nodesMap.get(item).check = true;
+      });
+    }
+  };
+
+  Tree.prototype.search = function search(value) {
+    var _this3 = this;
+
+    var recursionChildren = function recursionChildren(node) {
+      var childNodes = node.root ? node.root.childNodes : node.childNodes;
+      childNodes.forEach(function (item) {
+        item.visible = _this3.searchNodeMethod.call(item, value, item.data, item);
+        recursionChildren(item);
+      });
+
+      // 子节点有匹配项的情况父节点需要显示
+      if (!node.visible && childNodes.length) {
+        var hiddenAllChildren = void 0;
+        hiddenAllChildren = !childNodes.some(function (child) {
+          return child.visible;
+        });
+        if (!node.root) {
+          node.visible = !hiddenAllChildren;
+        } else {
+          node.root.visible = false;
+        }
+      }
+
+      // 节点显示的情况下展开所有子节点
+      if (node.visible && !node.isLeaf && !_this3.load) {
+        node.changeExpanded(true);
+      }
+    };
+    recursionChildren(this);
+  };
+
+  Tree.prototype.getCheckedNodes = function getCheckedNodes(leafOnly) {
+    var result = [];
+    if (leafOnly) {
+      this.nodesMap.forEach(function (item) {
+        if (item.checked && !item.data.children) {
+          result.push(item.data);
+        }
+      });
+    } else {
+      this.nodesMap.forEach(function (item) {
+        if (item.checked) {
+          result.push(item.data);
+        }
+      });
+    }
+    return result;
+  };
+
+  Tree.prototype.getCheckedKeys = function getCheckedKeys(leafOnly) {
+    var result = [];
+    if (leafOnly) {
+      this.nodesMap.forEach(function (item) {
+        if (item.checked && !item.data.children) {
+          result.push(item.key);
+        }
+      });
+    } else {
+      this.nodesMap.forEach(function (item) {
+        if (item.checked) {
+          result.push(item.key);
+        }
+      });
+    }
+    return result;
+  };
+
+  Tree.prototype.setCheckedKeys = function setCheckedKeys(checkArr) {
+    var _this4 = this;
+
+    if (!Array.isArray(checkArr)) {
+      throw new Error('需要输入一个key数组');
+    }
+    checkArr.forEach(function (item) {
+      _this4.nodesMap.get(item).check = true;
+    });
+  };
+
+  Tree.prototype.setChecked = function setChecked(key, checkState) {
+    var node = this.nodesMap.get(key);
+    if (!node) {
+      throw new Error('请输入正确的key');
+    }
+    node.check = checkState;
+  };
+
+  Tree.prototype.getHalfCheckedNodes = function getHalfCheckedNodes() {
+    var result = [];
+    this.nodesMap.forEach(function (item) {
+      if (item.indeterminate) {
+        result.push(item.data);
+      }
+    });
+    return result;
+  };
+
+  Tree.prototype.getHalfCheckedKeys = function getHalfCheckedKeys() {
+    var result = [];
+    this.nodesMap.forEach(function (item) {
+      if (item.indeterminate) {
+        result.push(item.data.key);
+      }
+    });
+    return result;
+  };
+
+  Tree.prototype.getCurrentKey = function getCurrentKey() {
+    for (var _iterator = this.nodesMap.values(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      var item = _ref;
+
+      if (item.selected) {
+        return item.data.key;
+      }
+    }
+    return null;
+  };
+
+  Tree.prototype.getCurrentNode = function getCurrentNode() {
+    for (var _iterator2 = this.nodesMap.values(), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      var item = _ref2;
+
+      if (item.selected) {
+        return item.data;
+      }
+    }
+    return null;
+  };
+
+  Tree.prototype.setCurrentKey = function setCurrentKey(key) {
+    if (key) {
+      this.handleSelectedChange(key);
+    } else {
+      this.nodesMap.forEach(function (node) {
+        node.selected = false;
+      });
+    }
+  };
+
+  Tree.prototype.getNode = function getNode(key) {
+    var node = this.nodesMap.get(key);
+    if (node) {
+      return node;
+    }
+    return null;
+  };
+
+  Tree.prototype.getCheckNode = function getCheckNode(nodeFlag) {
+    var arr = [];
+    this.nodesMap.forEach(function (item) {
+      if (item.checked) {
+        nodeFlag ? arr.push(item) : arr.push(item.data);
+      }
+    });
+    return arr;
+  };
+
+  Tree.prototype.getCheckNodeKey = function getCheckNodeKey() {
+    var arr = [];
+    this.getCheckNode(true).forEach(function (node) {
+      arr.push(node.key);
+    });
+    return arr;
+  };
+
+  Tree.prototype.getIndeterminateNode = function getIndeterminateNode(nodeFlag) {
+    var arr = [];
+    this.nodesMap.forEach(function (item) {
+      if (item.indeterminate) {
+        nodeFlag ? arr.push(item) : arr.push(item.data);
+      }
+    });
+    return arr;
+  };
+
+  Tree.prototype.getIndeterminateNodeKey = function getIndeterminateNodeKey() {
+    var arr = [];
+    this.getIndeterminateNode(true).forEach(function (node) {
+      arr.push(node.key);
+    });
+    return arr;
+  };
+
+  Tree.prototype.setCheckNode = function setCheckNode(keys) {
+    var bor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+    var nodesMap = this.nodesMap;
+
+    if (Array.isArray(keys)) {
+      keys.forEach(function (item) {
+        var node = nodesMap.get(item);
+        if (node) node.check = bor;
+      });
+    } else {
+      var node = nodesMap.get(keys);
+      if (node) nodesMap.get(keys).check = bor;
+    }
+  };
+
+  Tree.prototype.getCheckNodeTree = function getCheckNodeTree() {
+    var _this5 = this;
+
+    var root = this.root;
+
+    if (Array.isArray(root.data)) {
+      var newTree = [];
+      root.indeterminateChildNodes.forEach(function (item) {
+        newTree.push(copyNode(item, _this5));
+      });
+      return newTree;
+    } else {
+      return copyNode(root, this);
+    }
+  };
+
+  Tree.prototype.appendNodes = function appendNodes(key, nodes) {
+    var parent = this.nodesMap.get(key);
+    if (!parent) {
+      return;
+    }
+    if (Array.isArray(nodes)) {
+      if ((typeof nodes === 'undefined' ? 'undefined' : (0, _typeof3.default)(nodes)) === 'object') {
+        nodes.forEach(function (item) {
+          parent.appendChild(item);
+        });
+      }
+    } else if ((typeof nodes === 'undefined' ? 'undefined' : (0, _typeof3.default)(nodes)) === 'object') {
+      parent.appendChild(nodes);
+    }
+  };
+
+  Tree.prototype.delectNodeByKey = function delectNodeByKey(keys) {
+    var _this6 = this;
+
+    if (Array.isArray(keys)) {
+      keys.forEach(function (item) {
+        var node = _this6.nodesMap.get(item);
+        if (node) node.remove();
+      });
+    } else {
+      var node = this.nodesMap.get(keys);
+      node.remove();
+    }
+  };
+
+  return Tree;
+}();
+
+exports.default = Tree;
+
+
+var copyData = function copyData(data, tree) {
+  var newData = {};
+  for (var key in data) {
+    if (data.hasOwnProperty(key) && key !== tree.prop.children) {
+      newData[key] = data[key];
+    }
+  }
+  return newData;
+};
+var copyNode = function copyNode(node, tree) {
+  var newData = copyData(node.data, tree);
+  if (node.isLeaf) {
+    return newData;
+  }
+  newData[tree.prop.children] = [];
+  node.indeterminateChildNodes.forEach(function (item) {
+    newData[tree.prop.children].push(copyNode(item, tree));
+  });
+  return newData;
+};
+// const deepCopy = function(o) {
+//   if (o instanceof Array) {
+//     let n = []
+//     for (let i = 0; i < o.length; ++i) {
+//       n[i] = deepCopy(o[i])
+//     }
+//     return n
+//   } else if (o instanceof Object) {
+//     let n = {}
+//     for (let i in o) {
+//       n[i] = deepCopy(o[i])
+//     }
+//     return n
+//   } else {
+//     return o
+//   }
+// }

package/dist/_util/util.js

@@ -0,0 +1,166 @@
+'use strict';
+
+exports.__esModule = true;
+exports.isFunction = exports.getOffsetWidth = exports.escapeRegexpString = exports.assert = exports.isFirefox = exports.isEdge = exports.isIE = exports.coerceTruthyValueToArray = exports.arrayFind = exports.arrayFindIndex = exports.valueEquals = exports.getOffsetLeft = exports.noop = undefined;
+exports.getValueByPath = getValueByPath;
+
+var _vue = require('vue');
+
+var _vue2 = _interopRequireDefault(_vue);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var noop = exports.noop = function noop() {};
+
+var getScroll = function getScroll(w, top) {
+  var ret = top ? w.pageYOffset : w.pageXOffset;
+  var method = top ? 'scrollTop' : 'scrollLeft';
+  if (typeof ret !== 'number') {
+    var d = w.document;
+    // ie6,7,8 standard mode
+    ret = d.documentElement[method];
+    if (typeof ret !== 'number') {
+      // quirks mode
+      ret = d.body[method];
+    }
+  }
+  return ret;
+};
+
+var getClientPosition = function getClientPosition(elem) {
+  var box = void 0;
+  var x = void 0;
+  var y = void 0;
+  var doc = elem.ownerDocument;
+  var body = doc.body;
+  var docElem = doc && doc.documentElement;
+  box = elem.getBoundingClientRect();
+  x = box.left;
+  y = box.top;
+  x -= docElem.clientLeft || body.clientLeft || 0;
+  y -= docElem.clientTop || body.clientTop || 0;
+  return {
+    left: x,
+    top: y
+  };
+};
+
+var getOffsetLeft = exports.getOffsetLeft = function getOffsetLeft(el) {
+  var pos = getClientPosition(el);
+  var doc = el.ownerDocument;
+  var w = doc.defaultView || doc.parentWindow;
+  pos.left += getScroll(w);
+  return pos.left;
+};
+/**
+ *  获取对象深层级的对象，避免循环
+ * @export
+ * @param {*} sourceObj 源对象 {a:{b:{d:1}}}
+ * @param {*} pathName  path组成的数组 例如：'a.b.c'
+ * @param {*} defaultValue 如果没有值默认的值 []
+ */
+function getValueByPath(sourceObj, pathName, defaultValue) {
+  var getValue = function getValue(sourceObj, pathNameArray) {
+    var key = pathNameArray.shift();
+    var value = sourceObj[key];
+    if (value === undefined || value === null) {
+      return defaultValue;
+    } else if (pathNameArray.length === 0) {
+      return value;
+    } else if (pathNameArray.length > 0) {
+      return getValue(value, pathNameArray);
+    }
+  };
+  var pathNameArray = pathName.split('.');
+  return getValue(sourceObj, pathNameArray);
+}
+/**
+ *
+ * 判断两个数是否相等
+ * @param {*} a
+ * @param {*} b
+ * @returns
+ */
+var valueEquals = exports.valueEquals = function valueEquals(a, b) {
+  // see: https://stackoverflow.com/questions/3115982/how-to-check-if-two-arrays-are-equal-with-javascript
+  if (a === b) return true;
+  if (!(a instanceof Array)) return false;
+  if (!(b instanceof Array)) return false;
+  if (a.length !== b.length) return false;
+  for (var i = 0; i !== a.length; ++i) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+};
+// TODO: use native Array.find, Array.findIndex when IE support is dropped
+var arrayFindIndex = exports.arrayFindIndex = function arrayFindIndex(arr, pred) {
+  for (var i = 0; i !== arr.length; ++i) {
+    if (pred(arr[i])) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+var arrayFind = exports.arrayFind = function arrayFind(arr, pred) {
+  var idx = arrayFindIndex(arr, pred);
+  return idx !== -1 ? arr[idx] : undefined;
+};
+
+// coerce truthy value to array
+var coerceTruthyValueToArray = exports.coerceTruthyValueToArray = function coerceTruthyValueToArray(val) {
+  if (Array.isArray(val)) {
+    return val;
+  } else if (val) {
+    return [val];
+  } else {
+    return [];
+  }
+};
+
+var isIE = exports.isIE = function isIE() {
+  return !_vue2.default.prototype.$isServer && !isNaN(Number(document.documentMode));
+};
+
+var isEdge = exports.isEdge = function isEdge() {
+  return !_vue2.default.prototype.$isServer && navigator.userAgent.indexOf('Edge') > -1;
+};
+
+var isFirefox = exports.isFirefox = function isFirefox() {
+  return !_vue2.default.prototype.$isServer && !!window.navigator.userAgent.match(/firefox/i);
+};
+
+var assert = exports.assert = function assert(condition, msg) {
+  if (!condition) throw new Error('[mds-ui] ' + msg);
+};
+/**
+ *
+ * 特殊字符转译
+ * @param {string} [value='']
+ */
+var escapeRegexpString = exports.escapeRegexpString = function escapeRegexpString() {
+  var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return String(value).replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
+};
+/**
+ * Get element offset width
+ * @param {*} node HTMLDOMElemment
+ * @return {Number} width
+ */
+/**
+ * Get element offset width
+ * @param {*} node HTMLDOMElemment
+ * @return {Number} width
+ */
+var getOffsetWidth = exports.getOffsetWidth = function getOffsetWidth(node) {
+  return node ? node.offsetWidth : 0;
+};
+
+/** 判断是否为函数
+ * @param {*} functionToCheck
+ * @returns
+ */
+var isFunction = exports.isFunction = function isFunction(functionToCheck) {
+  var getType = {};
+  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
+};