@opentiny/vue-renderless 3.6.0 → 3.6.1-alpha.2

package/cascader-panel/node.js

@@ -1,199 +1,127 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import { isEqual } from '@opentiny/vue-renderless/common/object';
-import { capitalize } from '@opentiny/vue-renderless/common/string';
-import { isNull } from '@opentiny/vue-renderless/common/type';
-var uid = 0;
-var Node = function () {
-  function Node(data, config, parentNode) {
-    _classCallCheck(this, Node);
-    Object.assign(this, {
-      data: data,
-      config: config,
-      uid: uid++
-    });
+import "../chunk-PKUHTIDK.js";
+import { isEqual } from "@opentiny/vue-renderless/common/object";
+import { capitalize } from "@opentiny/vue-renderless/common/string";
+import { isNull } from "@opentiny/vue-renderless/common/type";
+let uid = 0;
+class Node {
+  constructor(data, config, parentNode) {
+    Object.assign(this, { data, config, uid: uid++ });
     this.parent = parentNode || null;
     this.level = !this.parent ? 1 : this.parent.level + 1;
     this.initState();
     this.initChildren();
   }
-  _createClass(Node, [{
-    key: "initState",
-    value: function initState() {
-      var _this$config = this.config,
-        value = _this$config.value,
-        label = _this$config.label;
-      this.value = this.data[value];
-      this.label = this.data[label];
-      this.pathNodes = this.calculatePathNodes();
-      this.path = this.pathNodes.map(function (node) {
-        return node.value;
-      });
-      this.pathLabels = this.pathNodes.map(function (node) {
-        return node.label;
-      });
-      Object.assign(this, {
-        loading: false,
-        loaded: false
-      });
-    }
-  }, {
-    key: "initChildren",
-    value: function initChildren() {
-      var _this = this;
-      var config = this.config;
-      var childrenKey = config.children;
-      var childrenData = this.data[childrenKey];
-      this.hasChildren = Array.isArray(childrenData);
-      this.children = (childrenData || []).map(function (child) {
-        return new Node(child, config, _this);
-      });
-    }
-  }, {
-    key: "isLeaf",
-    get: function get() {
-      var data = this.data,
-        loaded = this.loaded,
-        hasChildren = this.hasChildren,
-        children = this.children,
-        config = this.config;
-      var lazy = config.lazy,
-        leaf = config.leaf;
-      if (lazy) {
-        var leafValue = data[leaf];
-        var isLeaf = !isNull(leafValue) ? leafValue : loaded ? !children.length : false;
-        this.hasChildren = !isLeaf;
-        return isLeaf;
-      }
-      return !hasChildren;
-    }
-  }, {
-    key: "isDisabled",
-    get: function get() {
-      var data = this.data,
-        parent = this.parent,
-        config = this.config;
-      var checkStrictly = config.checkStrictly,
-        disabled = config.disabled;
-      var disabledKey = disabled;
-      return data[disabledKey] || !checkStrictly && parent && parent.isDisabled;
-    }
-  }, {
-    key: "calculatePathNodes",
-    value: function calculatePathNodes() {
-      var nodes = [this];
-      var parentNode = this.parent;
-      while (parentNode) {
-        nodes.unshift(parentNode);
-        parentNode = parentNode.parent;
-      }
-      return nodes;
-    }
-  }, {
-    key: "getValue",
-    value: function getValue() {
-      return this.value;
-    }
-  }, {
-    key: "getPath",
-    value: function getPath() {
-      return this.path;
-    }
-  }, {
-    key: "getValueByOption",
-    value: function getValueByOption() {
-      return this.config.emitPath ? this.getPath() : this.getValue();
-    }
-  }, {
-    key: "getText",
-    value: function getText(allLevels, separator) {
-      return allLevels ? this.pathLabels.join(separator) : this.label;
-    }
-  }, {
-    key: "isSameNode",
-    value: function isSameNode(checkedValue) {
-      var value = this.getValueByOption();
-      var isMultiple = this.config.multiple && Array.isArray(checkedValue);
-      return isMultiple ? checkedValue.some(function (val) {
-        return isEqual(val, value);
-      }) : isEqual(checkedValue, value);
-    }
-  }, {
-    key: "emit",
-    value: function emit(eventName) {
-      var parent = this.parent;
-      var handlerName = "onChild".concat(capitalize(eventName));
-      if (parent) {
-        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-        parent[handlerName] && parent[handlerName].apply(parent, args);
-        parent.emit.apply(parent, [eventName].concat(args));
-      }
+  initState() {
+    const { value, label } = this.config;
+    this.value = this.data[value];
+    this.label = this.data[label];
+    this.pathNodes = this.calculatePathNodes();
+    this.path = this.pathNodes.map((node) => node.value);
+    this.pathLabels = this.pathNodes.map((node) => node.label);
+    Object.assign(this, { loading: false, loaded: false });
+  }
+  initChildren() {
+    const { config } = this;
+    const childrenKey = config.children;
+    const childrenData = this.data[childrenKey];
+    this.hasChildren = Array.isArray(childrenData);
+    this.children = (childrenData || []).map((child) => new Node(child, config, this));
+  }
+  get isLeaf() {
+    const { data, loaded, hasChildren, children, config } = this;
+    const { lazy, leaf } = config;
+    if (lazy) {
+      const leafValue = data[leaf];
+      const isLeaf = !isNull(leafValue) ? leafValue : loaded ? !children.length : false;
+      this.hasChildren = !isLeaf;
+      return isLeaf;
+    }
+    return !hasChildren;
+  }
+  get isDisabled() {
+    const { data, parent, config } = this;
+    const { checkStrictly, disabled } = config;
+    const disabledKey = disabled;
+    return data[disabledKey] || !checkStrictly && parent && parent.isDisabled;
+  }
+  calculatePathNodes() {
+    const nodes = [this];
+    let parentNode = this.parent;
+    while (parentNode) {
+      nodes.unshift(parentNode);
+      parentNode = parentNode.parent;
+    }
+    return nodes;
+  }
+  getValue() {
+    return this.value;
+  }
+  getPath() {
+    return this.path;
+  }
+  getValueByOption() {
+    return this.config.emitPath ? this.getPath() : this.getValue();
+  }
+  getText(allLevels, separator) {
+    return allLevels ? this.pathLabels.join(separator) : this.label;
+  }
+  isSameNode(checkedValue) {
+    const value = this.getValueByOption();
+    const isMultiple = this.config.multiple && Array.isArray(checkedValue);
+    return isMultiple ? checkedValue.some((val) => isEqual(val, value)) : isEqual(checkedValue, value);
+  }
+  emit(eventName, ...args) {
+    const { parent } = this;
+    const handlerName = `onChild${capitalize(eventName)}`;
+    if (parent) {
+      parent[handlerName] && parent[handlerName](...args);
+      parent.emit(eventName, ...args);
     }
-  }, {
-    key: "broadcast",
-    value: function broadcast(eventName) {
-      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-        args[_key2 - 1] = arguments[_key2];
+  }
+  broadcast(eventName, ...args) {
+    const handlerName = `onParent${capitalize(eventName)}`;
+    this.children.forEach((child) => {
+      if (child) {
+        child.broadcast(eventName, ...args);
+        child[handlerName] && child[handlerName](...args);
       }
-      var handlerName = "onParent".concat(capitalize(eventName));
-      this.children.forEach(function (child) {
-        if (child) {
-          child.broadcast.apply(child, [eventName].concat(args));
-          child[handlerName] && child[handlerName].apply(child, args);
-        }
-      });
-    }
-  }, {
-    key: "onParentCheck",
-    value: function onParentCheck(checked) {
-      !this.isDisabled && this.setCheckState(checked);
-    }
-  }, {
-    key: "onChildCheck",
-    value: function onChildCheck() {
-      var children = this.children;
-      var validChildren = children.filter(function (child) {
-        return !child.isDisabled;
-      });
-      var checked = validChildren.length ? validChildren.every(function (child) {
-        return child.checked;
-      }) : false;
-      this.setCheckState(checked);
-    }
-  }, {
-    key: "syncCheckState",
-    value: function syncCheckState(checkedValue) {
-      var value = this.getValueByOption();
-      var checked = this.isSameNode(checkedValue, value);
-      this.doCheck(checked);
-    }
-  }, {
-    key: "setCheckState",
-    value: function setCheckState(checked) {
-      var totalNum = this.children.length;
-      var checkedNum = this.children.reduce(function (prevChild, nextChild) {
-        var num = nextChild.checked ? 1 : nextChild.indeterminate ? 0.5 : 0;
-        return prevChild + num;
-      }, 0);
-      this.checked = checked;
-      this.indeterminate = checkedNum !== totalNum && checkedNum > 0;
-    }
-  }, {
-    key: "doCheck",
-    value: function doCheck(isChecked) {
-      if (this.checked !== isChecked) {
-        if (this.config.checkStrictly) {
-          this.checked = isChecked;
-        } else {
-          this.broadcast('check', isChecked);
-          this.setCheckState(isChecked);
-          this.emit('check');
-        }
+    });
+  }
+  onParentCheck(checked) {
+    !this.isDisabled && this.setCheckState(checked);
+  }
+  onChildCheck() {
+    const { children } = this;
+    const validChildren = children.filter((child) => !child.isDisabled);
+    const checked = validChildren.length ? validChildren.every((child) => child.checked) : false;
+    this.setCheckState(checked);
+  }
+  syncCheckState(checkedValue) {
+    const value = this.getValueByOption();
+    const checked = this.isSameNode(checkedValue, value);
+    this.doCheck(checked);
+  }
+  setCheckState(checked) {
+    const totalNum = this.children.length;
+    const checkedNum = this.children.reduce((prevChild, nextChild) => {
+      const num = nextChild.checked ? 1 : nextChild.indeterminate ? 0.5 : 0;
+      return prevChild + num;
+    }, 0);
+    this.checked = checked;
+    this.indeterminate = checkedNum !== totalNum && checkedNum > 0;
+  }
+  doCheck(isChecked) {
+    if (this.checked !== isChecked) {
+      if (this.config.checkStrictly) {
+        this.checked = isChecked;
+      } else {
+        this.broadcast("check", isChecked);
+        this.setCheckState(isChecked);
+        this.emit("check");
       }
     }
-  }]);
-  return Node;
-}();
-export { Node as default };
+  }
+}
+export {
+  Node as default
+};

package/cascader-panel/store.js

@@ -1,80 +1,53 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import Node from './node';
-import { valueEquals, coerceTruthyValueToArray as toArray } from './index';
-var flatNodes = function flatNodes(data, leafOnly) {
-  return data.reduce(function (prev, node) {
-    if (node.isLeaf) {
-      prev.push(node);
-    } else {
-      !leafOnly && prev.push(node);
-      prev = prev.concat(flatNodes(node.children, leafOnly));
-    }
-    return prev;
-  }, []);
-};
-var Store = function () {
-  function Store(data, config) {
-    _classCallCheck(this, Store);
+import "../chunk-PKUHTIDK.js";
+import Node from "./node";
+import { valueEquals, coerceTruthyValueToArray as toArray } from "./index";
+const flatNodes = (data, leafOnly) => data.reduce((prev, node) => {
+  if (node.isLeaf) {
+    prev.push(node);
+  } else {
+    !leafOnly && prev.push(node);
+    prev = prev.concat(flatNodes(node.children, leafOnly));
+  }
+  return prev;
+}, []);
+class Store {
+  constructor(data, config) {
     this.config = config;
     this.initNodes(data);
   }
-  _createClass(Store, [{
-    key: "getNodes",
-    value: function getNodes() {
-      return this.nodes;
-    }
-  }, {
-    key: "initNodes",
-    value: function initNodes(data) {
-      var _this = this;
-      data = toArray(data);
-      this.nodes = data.map(function (nodeData) {
-        return new Node(nodeData, _this.config);
-      });
-      this.flattedNodes = this.getFlattedNodes(false, false);
-      this.leafNodes = this.getFlattedNodes(true, false);
-    }
-  }, {
-    key: "appendNode",
-    value: function appendNode(nodeData, parentNode) {
-      var config = this.config,
-        nodes = this.nodes;
-      var node = new Node(nodeData, config, parentNode);
-      var children = parentNode ? parentNode.children : nodes;
-      children.push(node);
-    }
-  }, {
-    key: "appendNodes",
-    value: function appendNodes(nodeDataList, parentNode) {
-      var _this2 = this;
-      nodeDataList = toArray(nodeDataList);
-      nodeDataList.forEach(function (nodeData) {
-        return _this2.appendNode(nodeData, parentNode);
-      });
-    }
-  }, {
-    key: "getFlattedNodes",
-    value: function getFlattedNodes(leafOnly) {
-      var cached = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var leafNodes = this.leafNodes,
-        flattedNodes = this.flattedNodes;
-      var cachedNodes = leafOnly ? leafNodes : flattedNodes;
-      return cached ? cachedNodes : flatNodes(this.nodes, leafOnly);
-    }
-  }, {
-    key: "getNodeByValue",
-    value: function getNodeByValue(value) {
-      if (value) {
-        var lazy = !this.config.lazy;
-        var nodes = this.getFlattedNodes(false, lazy).filter(function (node) {
-          return valueEquals(node.path, value) || node.value === value;
-        });
-        return nodes && nodes.length ? nodes[0] : null;
-      }
-      return null;
+  getNodes() {
+    return this.nodes;
+  }
+  initNodes(data) {
+    data = toArray(data);
+    this.nodes = data.map((nodeData) => new Node(nodeData, this.config));
+    this.flattedNodes = this.getFlattedNodes(false, false);
+    this.leafNodes = this.getFlattedNodes(true, false);
+  }
+  appendNode(nodeData, parentNode) {
+    const { config, nodes } = this;
+    const node = new Node(nodeData, config, parentNode);
+    const children = parentNode ? parentNode.children : nodes;
+    children.push(node);
+  }
+  appendNodes(nodeDataList, parentNode) {
+    nodeDataList = toArray(nodeDataList);
+    nodeDataList.forEach((nodeData) => this.appendNode(nodeData, parentNode));
+  }
+  getFlattedNodes(leafOnly, cached = true) {
+    const { leafNodes, flattedNodes } = this;
+    const cachedNodes = leafOnly ? leafNodes : flattedNodes;
+    return cached ? cachedNodes : flatNodes(this.nodes, leafOnly);
+  }
+  getNodeByValue(value) {
+    if (value) {
+      const lazy = !this.config.lazy;
+      const nodes = this.getFlattedNodes(false, lazy).filter((node) => valueEquals(node.path, value) || node.value === value);
+      return nodes && nodes.length ? nodes[0] : null;
     }
-  }]);
-  return Store;
-}();
-export { Store as default };
+    return null;
+  }
+}
+export {
+  Store as default
+};