@opentiny/vue-renderless 3.1.0-alpha.0

package/common/deps/tree-model/tree-store.js

@@ -0,0 +1,377 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { hasOwn, isNull } from '@opentiny/vue-renderless/common/type';
+import { getNodeKey } from '@opentiny/vue-renderless/common/deps/tree-model/util';
+import Node from '@opentiny/vue-renderless/common/deps/tree-model/node';
+var TreeStore = function () {
+  function TreeStore(options) {
+    var _this = this;
+    _classCallCheck(this, TreeStore);
+    this.currentNode = null;
+    this.currentNodeKey = null;
+    for (var option in options) {
+      if (hasOwn.call(options, option)) {
+        this[option] = options[option];
+      }
+    }
+    this.nodesMap = {};
+    this.root = new Node({
+      data: this.data,
+      store: this
+    });
+    if (this.lazy && this.load) {
+      this.load(this.root, function (data) {
+        _this.root.doCreateChildren(data);
+        _this._initDefaultCheckedNodes();
+      });
+    } else {
+      this._initDefaultCheckedNodes();
+    }
+  }
+  _createClass(TreeStore, [{
+    key: "filter",
+    value: function filter(value) {
+      var _this2 = this;
+      var lazy = this.lazy,
+        getMappingData = this.getMappingData,
+        filterNodeMethod = this.filterNodeMethod;
+      var walkTree = function walkTree(node) {
+        var childNodes = node.root ? node.root.childNodes : node.childNodes;
+        childNodes.forEach(function (child) {
+          var mappingData = getMappingData.call(_this2, child.data);
+          child.visible = filterNodeMethod.call(child, value, mappingData, child);
+          walkTree(child);
+        });
+        if (!node.visible && childNodes.length) {
+          var allHidden = !childNodes.some(function (_ref) {
+            var visible = _ref.visible;
+            return visible;
+          });
+          if (node.root) {
+            node.root.visible = allHidden === false;
+          } else {
+            node.visible = allHidden === false;
+          }
+        }
+        if (!value) return;
+        if (node.visible && !node.isLeaf && !lazy) node.expand();
+      };
+      walkTree(this);
+    }
+  }, {
+    key: "getMappingData",
+    value: function getMappingData(data) {
+      var props = this.props || {};
+      var mapping = {};
+      Object.keys(props).forEach(function (key) {
+        if (hasOwn.call(props, key)) {
+          mapping[key] = data[props[key]];
+        }
+      });
+      return Object.assign(data, mapping);
+    }
+  }, {
+    key: "setData",
+    value: function setData(newVal) {
+      if (newVal !== this.root.data) {
+        this.root.setData(newVal);
+        this._initDefaultCheckedNodes();
+      } else {
+        this.root.updateChildren();
+      }
+    }
+  }, {
+    key: "getNode",
+    value: function getNode(data) {
+      if (data instanceof Node) {
+        return data;
+      }
+      var nodeKey = _typeof(data) !== 'object' ? data : getNodeKey(this.key, data);
+      return this.nodesMap[nodeKey] || null;
+    }
+  }, {
+    key: "insertBefore",
+    value: function insertBefore(data, insertData) {
+      var refNode = this.getNode(insertData);
+      refNode.parent.insertBefore({
+        data: data
+      }, refNode);
+    }
+  }, {
+    key: "insertAfter",
+    value: function insertAfter(data, insertData) {
+      var refNode = this.getNode(insertData);
+      refNode.parent.insertAfter({
+        data: data
+      }, refNode);
+    }
+  }, {
+    key: "remove",
+    value: function remove(data) {
+      var treeNode = this.getNode(data);
+      if (treeNode && treeNode.parent) {
+        if (treeNode === this.currentNode) {
+          this.currentNode = null;
+        }
+        treeNode.parent.removeChild(treeNode);
+      }
+    }
+  }, {
+    key: "append",
+    value: function append(data, parentData) {
+      var parentNode = parentData ? this.getNode(parentData) : this.root;
+      parentNode && parentNode.insertChild({
+        data: data
+      });
+    }
+  }, {
+    key: "setDefaultCheckedKey",
+    value: function setDefaultCheckedKey(newValue) {
+      if (newValue !== this.defaultCheckedKeys) {
+        this.defaultCheckedKeys = newValue;
+        this._initDefaultCheckedNodes();
+      }
+    }
+  }, {
+    key: "_initDefaultCheckedNodes",
+    value: function _initDefaultCheckedNodes() {
+      var _this3 = this;
+      var defaultCheckedKeys = this.defaultCheckedKeys || [];
+      var nodesMap = this.nodesMap;
+      defaultCheckedKeys.forEach(function (checkedKey) {
+        var node = nodesMap[checkedKey];
+        node && node.setChecked(true, !_this3.checkStrictly);
+      });
+    }
+  }, {
+    key: "_initDefaultCheckedNode",
+    value: function _initDefaultCheckedNode(node) {
+      var defaultCheckedKeys = this.defaultCheckedKeys || [];
+      ~defaultCheckedKeys.indexOf(node.key) && node.setChecked(true, !this.checkStrictly);
+    }
+  }, {
+    key: "getCheckedKeys",
+    value: function getCheckedKeys() {
+      var _this4 = this;
+      var leafOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      return this.getCheckedNodes(leafOnly).map(function (node) {
+        return (node || {})[_this4.key];
+      });
+    }
+  }, {
+    key: "getHalfCheckedKeys",
+    value: function getHalfCheckedKeys() {
+      var _this5 = this;
+      return this.getHalfCheckedNodes().map(function (node) {
+        return (node || {})[_this5.key];
+      });
+    }
+  }, {
+    key: "deregisterNode",
+    value: function deregisterNode(node) {
+      var _this6 = this;
+      var key = this.key;
+      if (!key || !node || !node.data) return;
+      node.childNodes.forEach(function (child) {
+        _this6.deregisterNode(child);
+      });
+      delete this.nodesMap[node.key];
+    }
+  }, {
+    key: "registerNode",
+    value: function registerNode(node) {
+      var key = this.key;
+      if (!key || !node || !node.data) return;
+      var nodeKey = node.key;
+      if (nodeKey !== undefined) {
+        this.nodesMap[nodeKey] = node;
+      }
+    }
+  }, {
+    key: "getCheckedNodes",
+    value: function getCheckedNodes() {
+      var leafOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var includeHalfChecked = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var checkedNodes = [];
+      var walkTree = function walkTree(node) {
+        var childNodes = node.root ? node.root.childNodes : node.childNodes;
+        childNodes.forEach(function (child) {
+          var checked = child.checked,
+            indeterminate = child.indeterminate,
+            isLeaf = child.isLeaf,
+            data = child.data;
+          if ((checked || includeHalfChecked && indeterminate) && (!leafOnly || leafOnly && isLeaf)) {
+            checkedNodes.push(data);
+          }
+          walkTree(child);
+        });
+      };
+      walkTree(this);
+      return checkedNodes;
+    }
+  }, {
+    key: "getHalfCheckedNodes",
+    value: function getHalfCheckedNodes() {
+      var nodes = [];
+      var walkTree = function walkTree(node) {
+        var childNodes = node.root ? node.root.childNodes : node.childNodes;
+        childNodes.forEach(function (child) {
+          var indeterminate = child.indeterminate,
+            data = child.data;
+          indeterminate && nodes.push(data);
+          walkTree(child);
+        });
+      };
+      walkTree(this);
+      return nodes;
+    }
+  }, {
+    key: "_getAllNodes",
+    value: function _getAllNodes() {
+      var allNodes = [];
+      var nodesMap = this.nodesMap;
+      Object.keys(nodesMap).forEach(function (nodeKey) {
+        hasOwn.call(nodesMap, nodeKey) && allNodes.push(nodesMap[nodeKey]);
+      });
+      return allNodes;
+    }
+  }, {
+    key: "updateChildren",
+    value: function updateChildren(key, data) {
+      var node = this.nodesMap[key];
+      if (!node) return;
+      var childNodes = node.childNodes;
+      for (var i = childNodes.length - 1; i >= 0; i--) {
+        this.remove(childNodes[i].data);
+      }
+      for (var _i = 0, len = data.length; _i < len; _i++) {
+        var child = data[_i];
+        this.append(child, node.data);
+      }
+    }
+  }, {
+    key: "_setCheckedKeys",
+    value: function _setCheckedKeys(key) {
+      var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var checkedKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var nodes = this._getAllNodes().sort(function (prevNode, nextNode) {
+        return nextNode.level - prevNode.level;
+      });
+      var cache = Object.create(null);
+      var keys = Object.keys(checkedKeys);
+      nodes.forEach(function (node) {
+        node.setChecked(false, false);
+      });
+      for (var i = 0, len = nodes.length; i < len; i++) {
+        var node = nodes[i];
+        var nodeKey = node.data[key].toString();
+        var checked = ~keys.indexOf(nodeKey);
+        if (!checked) {
+          if (node.checked && !cache[nodeKey]) {
+            node.setChecked(false, false);
+          }
+        } else {
+          var parentNode = node.parent;
+          while (parentNode && parentNode.level > 0) {
+            cache[parentNode.data[key]] = true;
+            parentNode = parentNode.parent;
+          }
+          if (node.isLeaf || this.checkStrictly) {
+            node.setChecked(true, false);
+          } else if (leafOnly) {
+            (function () {
+              node.setChecked(false, false);
+              var walkTree = function walkTree(node) {
+                var childNodes = node.childNodes;
+                childNodes.forEach(function (child) {
+                  !child.isLeaf && child.setChecked(false, false);
+                  walkTree(child);
+                });
+              };
+              walkTree(node);
+            })();
+          } else {
+            node.setChecked(true, true);
+          }
+        }
+      }
+    }
+  }, {
+    key: "setDefaultExpandedKeys",
+    value: function setDefaultExpandedKeys(keys) {
+      var _this7 = this;
+      keys = keys || [];
+      this.defaultExpandedKeys = keys;
+      keys.forEach(function (key) {
+        var node = _this7.getNode(key);
+        node && node.expand(null, _this7.autoExpandParent);
+      });
+    }
+  }, {
+    key: "setCheckedKeys",
+    value: function setCheckedKeys(keys) {
+      var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      this.defaultCheckedKeys = keys;
+      var checkedKeys = {};
+      keys.forEach(function (key) {
+        checkedKeys[key] = true;
+      });
+      this._setCheckedKeys(this.key, leafOnly, checkedKeys);
+    }
+  }, {
+    key: "setCheckedNodes",
+    value: function setCheckedNodes(array) {
+      var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var key = this.key;
+      var checkedKeys = {};
+      array.forEach(function (item) {
+        checkedKeys[(item || {})[key]] = true;
+      });
+      this._setCheckedKeys(key, leafOnly, checkedKeys);
+    }
+  }, {
+    key: "setChecked",
+    value: function setChecked(data, checked, deep) {
+      var node = this.getNode(data);
+      node && node.setChecked(!!checked, deep);
+    }
+  }, {
+    key: "setCurrentNode",
+    value: function setCurrentNode(currentNode) {
+      var prevNode = this.currentNode;
+      if (prevNode) {
+        prevNode.isCurrent = false;
+      }
+      this.currentNode = currentNode;
+      if (currentNode) {
+        this.currentNode.isCurrent = true;
+      }
+    }
+  }, {
+    key: "getCurrentNode",
+    value: function getCurrentNode() {
+      return this.currentNode;
+    }
+  }, {
+    key: "setCurrentNodeKey",
+    value: function setCurrentNodeKey(key) {
+      if (isNull(key)) {
+        this.currentNode && (this.currentNode.isCurrent = false);
+        this.currentNode = null;
+        return;
+      }
+      var node = this.getNode(key);
+      node && this.setCurrentNode(node);
+    }
+  }, {
+    key: "setUserCurrentNode",
+    value: function setUserCurrentNode(node) {
+      var key = node[this.key];
+      var currNode = this.nodesMap[key];
+      this.setCurrentNode(currNode);
+    }
+  }]);
+  return TreeStore;
+}();
+export { TreeStore as default };

package/common/deps/tree-model/util.js

@@ -0,0 +1,14 @@
+export var NODE_KEY = '$treeNodeId';
+export var getNodeKey = function getNodeKey(key, data) {
+  if (!key) return data[NODE_KEY];
+  return data[key];
+};
+export var markNodeData = function markNodeData(node, data) {
+  if (!data || data[NODE_KEY]) return;
+  Object.defineProperty(data, NODE_KEY, {
+    value: node.id,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+};

package/common/deps/upload-ajax.js

@@ -0,0 +1,71 @@
+import { hasOwn } from '@opentiny/vue-renderless/common/type';
+import { xss } from '@opentiny/vue-renderless/common/xss.js';
+var getBody = function getBody(xhr) {
+  var text = xhr.responseText || xhr.response;
+  if (!text) {
+    return text;
+  }
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return text;
+  }
+};
+var getError = function getError(action, option, xhr) {
+  var errorText;
+  if (xhr.response) {
+    errorText = xhr.response.error || xhr.response;
+  } else if (xhr.responseText) {
+    errorText = xhr.responseText;
+  } else {
+    errorText = "fail to post ".concat(action, " ").concat(xhr.status);
+  }
+  var error = new Error(errorText);
+  error.status = xhr.status;
+  error.method = 'post';
+  error.url = action;
+  return error;
+};
+export default (function (option) {
+  if (typeof XMLHttpRequest === 'undefined') {
+    return;
+  }
+  var xhr = new XMLHttpRequest();
+  var action = xss.filterUrl(option.action);
+  if (xhr.upload) {
+    xhr.upload.onprogress = function (event) {
+      if (event.total > 0) {
+        event.percent = event.loaded / event.total * 100;
+      }
+      option.onProgress(event);
+    };
+  }
+  var formData = new FormData();
+  if (option.data) {
+    Object.keys(option.data).forEach(function (key) {
+      formData.append(key, option.data[key]);
+    });
+  }
+  formData.append(option.filename, option.file, option.file.name);
+  xhr.onerror = function (event) {
+    option.onError(event);
+  };
+  xhr.onload = function () {
+    if (xhr.status < 200 || xhr.status >= 300) {
+      return option.onError(getError(action, option, xhr));
+    }
+    option.onSuccess(getBody(xhr));
+  };
+  xhr.open('post', action, true);
+  if (option.withCredentials && 'withCredentials' in xhr) {
+    xhr.withCredentials = true;
+  }
+  var headers = option.headers || {};
+  for (var header in headers) {
+    if (hasOwn.call(headers, header) && headers[header] !== null) {
+      xhr.setRequestHeader(header, headers[header]);
+    }
+  }
+  xhr.send(formData);
+  return xhr;
+});

package/common/deps/vue-emitter.js

@@ -0,0 +1,30 @@
+export default (function (vm) {
+  var _broadcast = function broadcast(vm, componentName, eventName, params) {
+    vm.$children.forEach(function (child) {
+      var name = child.$options.componentName;
+      if (name === componentName) {
+        child.$emit(eventName, params);
+      } else {
+        _broadcast(child, componentName, eventName, params);
+      }
+    });
+  };
+  return {
+    dispatch: function dispatch(componentName, eventName, params) {
+      var parent = vm.$parent || vm.$root;
+      var name = parent.$options.componentName;
+      while (parent && !parent.$attrs.novalid && (!name || name !== componentName)) {
+        parent = parent.$parent;
+        if (parent) {
+          name = parent.$options.componentName;
+        }
+      }
+      if (parent) {
+        parent.$emit.apply(parent, [eventName].concat(params));
+      }
+    },
+    broadcast: function broadcast(componentName, eventName, params) {
+      _broadcast(vm, componentName, eventName, params);
+    }
+  };
+});