@mdsfe/mds-ui 0.2.0

package/dist/_util/soda.js

@@ -0,0 +1,54 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _util = require('./util');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Soda = function () {
+  function Soda(vm) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _classCallCheck3.default)(this, Soda);
+
+    this.mutations = options.mutations;
+    (0, _util.assert)(typeof options.state === 'function', 'Soda state must be a function.');
+    this.state = options.state();
+    this.root = vm;
+    this.init(vm);
+    return this;
+  }
+
+  Soda.prototype.commit = function commit(type, payload) {
+    this.mutations[type].call(this, this.state, payload);
+  };
+
+  Soda.prototype.init = function init() {
+    var _this = this;
+
+    var root = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.root;
+
+    var map = function map(_vm) {
+      if (!_vm.$children.length) return;
+      _vm.$children.forEach(function (child) {
+        inject(child);
+        map(child);
+      });
+    };
+    var inject = function inject(_vm) {
+      if (typeof _vm.soda === 'undefined' || typeof _this.$soda !== 'undefined') return;
+      _vm.$soda = _this;
+      _vm.soda = _this.state;
+    };
+    root.soda = this.state;
+    map(root);
+  };
+
+  return Soda;
+}();
+
+exports.default = Soda;

package/dist/_util/switchcase.js

@@ -0,0 +1,22 @@
+'use strict';
+
+exports.__esModule = true;
+var executeIfFunction = function executeIfFunction(f) {
+  return typeof f === 'function' ? f() : f;
+};
+
+var switchcase = exports.switchcase = function switchcase(cases) {
+  return function (defaultCase) {
+    return function (key) {
+      return key in cases ? cases[key] : defaultCase;
+    };
+  };
+};
+
+var switchcaseF = exports.switchcaseF = function switchcaseF(cases) {
+  return function (defaultCase) {
+    return function (key) {
+      return executeIfFunction(switchcase(cases)(defaultCase)(key));
+    };
+  };
+};

package/dist/_util/throttleByAnimationFrame.js

@@ -0,0 +1,70 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _defineProperty = require('babel-runtime/core-js/object/define-property');
+
+var _defineProperty2 = _interopRequireDefault(_defineProperty);
+
+exports.default = throttleByAnimationFrame;
+exports.throttleByAnimationFrameDecorator = throttleByAnimationFrameDecorator;
+
+var _getRequestAnimationFrame = require('./getRequestAnimationFrame');
+
+var _getRequestAnimationFrame2 = _interopRequireDefault(_getRequestAnimationFrame);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var reqAnimFrame = (0, _getRequestAnimationFrame2.default)();
+
+function throttleByAnimationFrame(fn) {
+  var requestId = void 0;
+
+  var later = function later(args) {
+    return function () {
+      requestId = null;
+      fn.apply(undefined, args);
+    };
+  };
+
+  var throttled = function throttled() {
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    if (requestId == null) {
+      requestId = reqAnimFrame(later(args));
+    }
+  };
+
+  throttled.cancel = function () {
+    return (0, _getRequestAnimationFrame.cancelRequestAnimationFrame)(requestId);
+  };
+
+  return throttled;
+}
+
+function throttleByAnimationFrameDecorator() {
+  return function (target, key, descriptor) {
+    var fn = descriptor.value;
+    var definingProperty = false;
+    return {
+      configurable: true,
+      get: function get() {
+        if (definingProperty || this === target.prototype || this.hasOwnProperty(key)) {
+          return fn;
+        }
+
+        var boundFn = throttleByAnimationFrame(fn.bind(this));
+        definingProperty = true;
+        (0, _defineProperty2.default)(this, key, {
+          value: boundFn,
+          configurable: true,
+          writable: true
+        });
+        definingProperty = false;
+        return boundFn;
+      }
+    };
+  };
+}

package/dist/_util/tree/node.js

@@ -0,0 +1,412 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var defaultId = 0;
+
+var Node = function () {
+  function Node(options) {
+    (0, _classCallCheck3.default)(this, Node);
+
+    this.id = defaultId++;
+    this.checked = false;
+    this.indeterminate = false;
+    this.data = null;
+    this.expanded = false;
+    this.parent = null;
+    this.isLeaf = false;
+
+    // 是否显示，用于搜索
+    this.visible = true;
+
+    for (var name in options) {
+      if (options.hasOwnProperty(name)) {
+        this[name] = options[name];
+      }
+    }
+
+    this.level = 0;
+    // 是否被选中
+    this.selected = false;
+    // 是否已经加载完毕，用于懒加载
+    this.loaded = false;
+    // 是否是加载中状态，用于懒加载
+    this.loading = false;
+    this.childNodes = [];
+    this.parent ? this.level = this.parent.level + 1 : this.level = 0;
+    this.update();
+  }
+
+  Node.prototype.update = function update() {
+    var _this = this;
+
+    if (!this.data) {
+      this.handleIsLeaf();
+      return;
+    }
+    var data = this.data;
+    var prop = this.tree.prop;
+
+    // 生成_nodeId
+    // this.markData(data)
+    // 非根节点添加到nodesMap中
+    this.fillNodesMap();
+    // 处理defaultExpandAll
+    if (!this.load && this.tree.defaultExpandAll) {
+      this.expanded = true;
+    }
+    // 处理defaultExpandedKeys
+    if (!this.load && this.tree.defaultExpandedKeys) {
+      this.tree.defaultExpandedKeys.forEach(function (item) {
+        if (_this.key === item) {
+          _this.expanded = true;
+          if (_this.tree.autoExpandParent) {
+            _this.getPath(true).forEach(function (node) {
+              node.expanded = true;
+            });
+          }
+        }
+      });
+    }
+
+    // 生成childNodes
+    var children = void 0;
+    // 根节点的情况把整个data作为children
+    if (Array.isArray(data) && this.level === 0) {
+      children = data;
+      this.id = 'root';
+    } else if (data.hasOwnProperty(prop.children)) {
+      children = data[prop.children];
+    } else {
+      if (!this.tree.load) this.isLeaf = true;
+    }
+
+    if (Array.isArray(children) && children.length > 0) {
+      children.forEach(function (data) {
+        _this.appendChild(data);
+      });
+    } else {
+      if (!this.tree.load) this.isLeaf = true;
+    }
+    this.handleIsLeaf();
+  };
+
+  Node.prototype.handleIsLeaf = function handleIsLeaf() {
+    // 懒加载且未加载的情况
+    if (this.tree.load && !this.loaded) {
+      this.isLeaf = this.getTrueData('isLeaf');
+    }
+    // 非懒加载或懒加载但已加载的情况
+    if (!this.tree.load || this.tree.load && this.loaded) {
+      var childNodes = this.childNodes;
+      this.isLeaf = !childNodes || childNodes.length === 0;
+    }
+  };
+
+  Node.prototype.fillNodesMap = function fillNodesMap() {
+    var key = this.key;
+    if (!key && this.level !== 0) {
+      throw new Error('必须指定节点的key');
+    }
+    if (key) {
+      // 处理初始选中的节点
+      this.handleSelectedKey(key);
+      if (this.tree.nodesMap.get(key)) {
+        throw new Error('节点的key不能重复');
+      }
+      this.tree.nodesMap.set(key, this);
+    }
+  };
+
+  Node.prototype.handleSelectedKey = function handleSelectedKey(key) {
+    this.selected = false;
+    if (this.tree.selectedKey === key) {
+      this.selected = true;
+    }
+  };
+
+  Node.prototype.appendChild = function appendChild(data, index) {
+    var child = new Node({
+      parent: this,
+      data: data,
+      tree: this.tree
+    });
+    if (index) {
+      this.childNodes.splice(index, 0, child);
+    } else {
+      this.childNodes.push(child);
+    }
+  };
+
+  Node.prototype.getTrueData = function getTrueData(prop) {
+    var props = this.tree.prop[prop];
+    var data = this.data;
+    if (!data) return;
+    if (data.hasOwnProperty(props)) {
+      return data[props];
+    } else if (data.hasOwnProperty(prop)) {
+      return data[prop];
+    } else {
+      return null;
+    }
+  };
+
+  Node.prototype.markData = function markData(data) {
+    Object.defineProperty(data, '_node', {
+      value: this,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+    if (!Array.isArray(data)) {
+      Object.defineProperty(data, '_nodeId', {
+        value: this.id,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    } else if (this.level === 0) {
+      Object.defineProperty(data, '_nodeId', {
+        value: 'root',
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+  };
+
+  Node.prototype.changeExpanded = function changeExpanded(value) {
+    if (this.tree.load && !this.loaded) {
+      this.loadNode();
+    }
+    if (!this.tree.load || this.loaded) {
+      this.expanded = value;
+    }
+    // 手风琴模式展开的时候所有兄弟节点收起
+    if (this.tree.accordion && value && !this.tree.searchNodeMethod) {
+      this.siblingsNodes.forEach(function (node) {
+        node.expanded = false;
+      });
+    }
+  };
+
+  Node.prototype.loadNode = function loadNode() {
+    var _this2 = this;
+
+    var node = this;
+    if (node.loaded || node.loading || node.childNodes.length > 0) {
+      return;
+    }
+    node.loading = true;
+    node.tree.load(node.data, function (data) {
+      if (!Array.isArray(data)) throw new Error('传入子元素必须是数组');
+      data.forEach(function (data) {
+        node.appendChild(data);
+      });
+      node.loading = false;
+      node.loaded = true;
+      node.check = false;
+      node.expanded = true;
+      _this2.handleIsLeaf();
+    });
+  };
+
+  Node.prototype.getPath = function getPath(nodeFlag) {
+    var arr = [];
+    var n = 0;
+    var node = this;
+    // if (Array.isArray(this.tree.root)) {
+    //   n = 1
+    // }
+    while (node.level > n) {
+      arr.push(nodeFlag ? node : node.data);
+      node = node.parent;
+    }
+    return arr;
+  };
+
+  Node.prototype.handleCheckChange = function handleCheckChange() {
+    var checked = this.checked;
+    this.childNodes.forEach(function (node) {
+      node.check = checked;
+    });
+    if (this.parent) {
+      this.parent.handleChildCheckChange();
+    }
+  };
+
+  Node.prototype.handleChildCheckChange = function handleChildCheckChange() {
+    if (Array.isArray(this.data) || this.level === 0) {
+      return;
+    }
+    if (this.childNodes.length === this.checkedChildNodes.length && this.childNodes.length !== 0) {
+      this.checked = true;
+      this.indeterminate = false;
+    } else if (this.checkedChildNodes.length > 0) {
+      this.checked = false;
+      this.indeterminate = true;
+    } else {
+      this.checked = false;
+      this.indeterminate = false;
+      for (var i = 0; i < this.childNodes.length; i++) {
+        if (this.childNodes[i].indeterminate) {
+          this.indeterminate = true;
+          break;
+        }
+      }
+    }
+    this.parent.handleChildCheckChange();
+  };
+
+  Node.prototype.after = function after(node) {
+    var oldIndex = node.index;
+    node.parent.childNodes.splice(oldIndex, 1);
+    node.parent.handleChildCheckChange();
+    if (node.parent.childNodes.length === 0) {
+      node.parent.isLeaf = true;
+    }
+    node.parent = this.parent;
+    node.level = this.level;
+    this.parent.childNodes.splice(this.index + 1, 0, node);
+    this.handleChildCheckChange();
+  };
+
+  Node.prototype.first = function first(node) {
+    var oldIndex = node.index;
+    node.parent.childNodes.splice(oldIndex, 1);
+    node.parent.handleChildCheckChange();
+    if (node.parent.childNodes.length === 0) {
+      node.parent.isLeaf = true;
+    }
+    this.isLeaf = false;
+    node.parent = this;
+    node.level = this.level + 1;
+    this.childNodes.splice(0, 0, node);
+    this.handleChildCheckChange();
+  };
+
+  Node.prototype.append = function append(node) {
+    var oldIndex = node.index;
+    node.parent.childNodes.splice(oldIndex, 1);
+    node.parent.handleChildCheckChange();
+    if (node.parent.childNodes.length === 0) {
+      node.parent.isLeaf = true;
+    }
+    this.isLeaf = false;
+    node.parent = this;
+    node.level = this.level + 1;
+    this.childNodes.push(node);
+    this.handleChildCheckChange();
+  };
+
+  Node.prototype.moveNode = function moveNode(node, index) {
+    var oldIndex = node.index;
+    node.parent.childNodes.splice(oldIndex, 1);
+    node.parent.handleChildCheckChange();
+    if (node.parent.childNodes.length === 0) {
+      node.parent.isLeaf = true;
+    }
+    this.isLeaf = false;
+    node.parent = this;
+    node.level = this.level + 1;
+    if (index !== null) {
+      this.childNodes.splice(index, 0, node);
+    } else {
+      this.childNodes.push(node);
+    }
+    this.handleChildCheckChange();
+  };
+
+  Node.prototype.remove = function remove() {
+    var node = this;
+    var index = node.index;
+    node.parent.childNodes.splice(index, 1);
+    node.parent.handleChildCheckChange();
+    node.tree.nodesMap.delete(node.id);
+    node = null;
+  };
+
+  (0, _createClass3.default)(Node, [{
+    key: 'label',
+    get: function get() {
+      return this.getTrueData('label');
+    }
+  }, {
+    key: 'key',
+    get: function get() {
+      return this.getTrueData('key');
+    }
+  }, {
+    key: 'disabled',
+    get: function get() {
+      return this.getTrueData('disabled');
+    }
+  }, {
+    key: 'check',
+    get: function get() {
+      return this.checked;
+    },
+    set: function set(val) {
+      if (val !== this.checked) {
+        this.checked = val;
+        this.handleCheckChange();
+      }
+    }
+  }, {
+    key: 'siblingsNodes',
+    get: function get() {
+      var arr = [];
+      var currentNode = this;
+      this.parent.childNodes.forEach(function (node) {
+        if (node.id !== currentNode.id) {
+          arr.push(node);
+        }
+      });
+      return arr;
+    }
+  }, {
+    key: 'checkedChildNodes',
+    get: function get() {
+      var arr = [];
+      this.childNodes.forEach(function (node) {
+        if (node.checked) arr.push(node);
+      });
+      return arr;
+    }
+  }, {
+    key: 'indeterminateChildNodes',
+    get: function get() {
+      var arr = [];
+      this.childNodes.forEach(function (node) {
+        if (node.checked || node.indeterminate) arr.push(node);
+      });
+      return arr;
+    }
+  }, {
+    key: 'isExpanded',
+    get: function get() {
+      return this.expanded;
+    },
+    set: function set(value) {
+      this.changeExpanded(value);
+    }
+  }, {
+    key: 'index',
+    get: function get() {
+      return this.parent.childNodes.indexOf(this);
+    }
+  }]);
+  return Node;
+}();
+
+exports.default = Node;