cbvirtua 1.0.56 → 1.0.58

package/src/packages/tree/src/model/tree-store.js

@@ -1,340 +0,0 @@
-import Node from './node';
-import { getNodeKey } from './util';
-
-export default class TreeStore {
-  constructor(options) {
-    this.currentNode = null;
-    this.currentNodeKey = null;
-
-    for (let option in options) {
-      if (options.hasOwnProperty(option)) {
-        this[option] = options[option];
-      }
-    }
-
-    this.nodesMap = {};
-
-    this.root = new Node({
-      data: this.data,
-      store: this
-    });
-
-    if (this.lazy && this.load) {
-      const loadFn = this.load;
-      loadFn(this.root, (data) => {
-        this.root.doCreateChildren(data);
-        this._initDefaultCheckedNodes();
-      });
-    } else {
-      this._initDefaultCheckedNodes();
-    }
-  }
-
-  filter(value) {
-    const filterNodeMethod = this.filterNodeMethod;
-    const lazy = this.lazy;
-    const traverse = function(node) {
-      const childNodes = node.root ? node.root.childNodes : node.childNodes;
-
-      childNodes.forEach((child) => {
-        child.visible = filterNodeMethod.call(child, value, child.data, child);
-
-        traverse(child);
-      });
-
-      if (!node.visible && childNodes.length) {
-        let allHidden = true;
-        allHidden = !childNodes.some(child => child.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();
-    };
-
-    traverse(this);
-  }
-
-  setData(newVal) {
-    const instanceChanged = newVal !== this.root.data;
-    if (instanceChanged) {
-      this.root.setData(newVal);
-      this._initDefaultCheckedNodes();
-    } else {
-      this.root.updateChildren();
-    }
-  }
-
-  getNode(data) {
-    if (data instanceof Node) return data;
-    const key = typeof data !== 'object' ? data : getNodeKey(this.key, data);
-    return this.nodesMap[key] || null;
-  }
-
-  insertBefore(data, refData) {
-    const refNode = this.getNode(refData);
-    refNode.parent.insertBefore({ data }, refNode);
-  }
-
-  insertAfter(data, refData) {
-    const refNode = this.getNode(refData);
-    refNode.parent.insertAfter({ data }, refNode);
-  }
-
-  remove(data) {
-    const node = this.getNode(data);
-
-    if (node && node.parent) {
-      if (node === this.currentNode) {
-        this.currentNode = null;
-      }
-      node.parent.removeChild(node);
-    }
-  }
-
-  append(data, parentData) {
-    const parentNode = parentData ? this.getNode(parentData) : this.root;
-
-    if (parentNode) {
-      parentNode.insertChild({ data });
-    }
-  }
-
-  _initDefaultCheckedNodes() {
-    const defaultCheckedKeys = this.defaultCheckedKeys || [];
-    const nodesMap = this.nodesMap;
-
-    defaultCheckedKeys.forEach((checkedKey) => {
-      const node = nodesMap[checkedKey];
-
-      if (node) {
-        node.setChecked(true, !this.checkStrictly);
-      }
-    });
-  }
-
-  _initDefaultCheckedNode(node) {
-    const defaultCheckedKeys = this.defaultCheckedKeys || [];
-
-    if (defaultCheckedKeys.indexOf(node.key) !== -1) {
-      node.setChecked(true, !this.checkStrictly);
-    }
-  }
-
-  setDefaultCheckedKey(newVal) {
-    if (newVal !== this.defaultCheckedKeys) {
-      this.defaultCheckedKeys = newVal;
-      this._initDefaultCheckedNodes();
-    }
-  }
-
-  registerNode(node) {
-    const key = this.key;
-    if (!key || !node || !node.data) return;
-
-    const nodeKey = node.key;
-    if (nodeKey !== undefined) this.nodesMap[node.key] = node;
-  }
-
-  deregisterNode(node) {
-    const key = this.key;
-    if (!key || !node || !node.data) return;
-
-    node.childNodes.forEach(child => {
-      this.deregisterNode(child);
-    });
-
-    delete this.nodesMap[node.key];
-  }
-
-  getCheckedNodes(leafOnly = false, includeHalfChecked = false) {
-    const checkedNodes = [];
-    const traverse = function(node) {
-      const childNodes = node.root ? node.root.childNodes : node.childNodes;
-
-      childNodes.forEach((child) => {
-        if ((child.checked || (includeHalfChecked && child.indeterminate)) && (!leafOnly || (leafOnly && child.isLeaf))) {
-          checkedNodes.push(child.data);
-        }
-
-        traverse(child);
-      });
-    };
-
-    traverse(this);
-
-    return checkedNodes;
-  }
-
-  getCheckedKeys(leafOnly = false) {
-    return this.getCheckedNodes(leafOnly).map((data) => (data || {})[this.key]);
-  }
-
-  getHalfCheckedNodes() {
-    const nodes = [];
-    const traverse = function(node) {
-      const childNodes = node.root ? node.root.childNodes : node.childNodes;
-
-      childNodes.forEach((child) => {
-        if (child.indeterminate) {
-          nodes.push(child.data);
-        }
-
-        traverse(child);
-      });
-    };
-
-    traverse(this);
-
-    return nodes;
-  }
-
-  getHalfCheckedKeys() {
-    return this.getHalfCheckedNodes().map((data) => (data || {})[this.key]);
-  }
-
-  _getAllNodes() {
-    const allNodes = [];
-    const nodesMap = this.nodesMap;
-    for (let nodeKey in nodesMap) {
-      if (nodesMap.hasOwnProperty(nodeKey)) {
-        allNodes.push(nodesMap[nodeKey]);
-      }
-    }
-
-    return allNodes;
-  }
-
-  updateChildren(key, data) {
-    const node = this.nodesMap[key];
-    if (!node) return;
-    const childNodes = node.childNodes;
-    for (let i = childNodes.length - 1; i >= 0; i--) {
-      const child = childNodes[i];
-      this.remove(child.data);
-    }
-    for (let i = 0, j = data.length; i < j; i++) {
-      const child = data[i];
-      this.append(child, node.data);
-    }
-  }
-
-  _setCheckedKeys(key, leafOnly = false, checkedKeys) {
-    const allNodes = this._getAllNodes().sort((a, b) => b.level - a.level);
-    const cache = Object.create(null);
-    const keys = Object.keys(checkedKeys);
-    allNodes.forEach(node => node.setChecked(false, false));
-    for (let i = 0, j = allNodes.length; i < j; i++) {
-      const node = allNodes[i];
-      const nodeKey = node.data[key].toString();
-      let checked = keys.indexOf(nodeKey) > -1;
-      if (!checked) {
-        if (node.checked && !cache[nodeKey]) {
-          node.setChecked(false, false);
-        }
-        continue;
-      }
-
-      let parent = node.parent;
-      while (parent && parent.level > 0) {
-        cache[parent.data[key]] = true;
-        parent = parent.parent;
-      }
-
-      if (node.isLeaf || this.checkStrictly) {
-        node.setChecked(true, false);
-        continue;
-      }
-      node.setChecked(true, true);
-
-      if (leafOnly) {
-        node.setChecked(false, false);
-        const traverse = function(node) {
-          const childNodes = node.childNodes;
-          childNodes.forEach((child) => {
-            if (!child.isLeaf) {
-              child.setChecked(false, false);
-            }
-            traverse(child);
-          });
-        };
-        traverse(node);
-      }
-    }
-  }
-
-  setCheckedNodes(array, leafOnly = false) {
-    const key = this.key;
-    const checkedKeys = {};
-    array.forEach((item) => {
-      checkedKeys[(item || {})[key]] = true;
-    });
-
-    this._setCheckedKeys(key, leafOnly, checkedKeys);
-  }
-
-  setCheckedKeys(keys, leafOnly = false) {
-    this.defaultCheckedKeys = keys;
-    const key = this.key;
-    const checkedKeys = {};
-    keys.forEach((key) => {
-      checkedKeys[key] = true;
-    });
-
-    this._setCheckedKeys(key, leafOnly, checkedKeys);
-  }
-
-  setDefaultExpandedKeys(keys) {
-    keys = keys || [];
-    this.defaultExpandedKeys = keys;
-
-    keys.forEach((key) => {
-      const node = this.getNode(key);
-      if (node) node.expand(null, this.autoExpandParent);
-    });
-  }
-
-  setChecked(data, checked, deep) {
-    const node = this.getNode(data);
-
-    if (node) {
-      node.setChecked(!!checked, deep);
-    }
-  }
-
-  getCurrentNode() {
-    return this.currentNode;
-  }
-
-  setCurrentNode(currentNode) {
-    const prevCurrentNode = this.currentNode;
-    if (prevCurrentNode) {
-      prevCurrentNode.isCurrent = false;
-    }
-    this.currentNode = currentNode;
-    this.currentNode.isCurrent = true;
-  }
-
-  setUserCurrentNode(node) {
-    const key = node[this.key];
-    const currNode = this.nodesMap[key];
-    this.setCurrentNode(currNode);
-  }
-
-  setCurrentNodeKey(key) {
-    if (key === null || key === undefined) {
-      this.currentNode && (this.currentNode.isCurrent = false);
-      this.currentNode = null;
-      return;
-    }
-    const node = this.getNode(key);
-    if (node) {
-      this.setCurrentNode(node);
-    }
-  }
-};

package/src/packages/tree/src/model/util.js

@@ -1,27 +0,0 @@
-export const NODE_KEY = '$treeNodeId';
-
-export const markNodeData = function(node, data) {
-  if (!data || data[NODE_KEY]) return;
-  Object.defineProperty(data, NODE_KEY, {
-    value: node.id,
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-};
-
-export const getNodeKey = function(key, data) {
-  if (!key) return data[NODE_KEY];
-  return data[key];
-};
-
-export const findNearestComponent = (element, componentName) => {
-  let target = element;
-  while (target && target.tagName !== 'BODY') {
-    if (target.__vue__ && target.__vue__.$options.name === componentName) {
-      return target.__vue__;
-    }
-    target = target.parentNode;
-  }
-  return null;
-};

package/src/packages/tree/src/tree-node.vue

@@ -1,279 +0,0 @@
-<template>
-  <div
-    class="el-tree-node"
-    @click.stop="handleClick"
-    @contextmenu="($event) => this.handleContextMenu($event)"
-    v-show="node.visible"
-    :class="{
-      'is-expanded': expanded,
-      'is-current': node.isCurrent,
-      'is-hidden': !node.visible,
-      'is-focusable': !node.disabled,
-      'is-checked': !node.disabled && node.checked
-    }"
-    role="treeitem"
-    tabindex="-1"
-    :aria-expanded="expanded"
-    :aria-disabled="node.disabled"
-    :aria-checked="node.checked"
-    :draggable="tree.draggable"
-    @dragstart.stop="handleDragStart"
-    @dragover.stop="handleDragOver"
-    @dragend.stop="handleDragEnd"
-    @drop.stop="handleDrop"
-    ref="node"
-  >
-    <div class="el-tree-node__content"
-      :style="{ 'padding-left': (node.level - 1) * tree.indent + 'px' }">
-      <span
-        @click.stop="handleExpandIconClick"
-        :class="[
-          { 'is-leaf': node.isLeaf, expanded: !node.isLeaf && expanded },
-          'el-tree-node__expand-icon',
-          tree.iconClass ? tree.iconClass : 'el-icon-caret-right'
-        ]"
-      >
-      </span>
-      <el-checkbox
-        v-if="showCheckbox"
-        v-model="node.checked"
-        :indeterminate="node.indeterminate"
-        :disabled="!!node.disabled"
-        @click.native.stop
-        @change="handleCheckChange"
-      >
-      </el-checkbox>
-      <span
-        v-if="node.loading"
-        class="el-tree-node__loading-icon el-icon-loading">
-      </span>
-      <node-content :node="node"></node-content>
-    </div>
-    <el-collapse-transition>
-      <div
-        class="el-tree-node__children"
-        v-if="!renderAfterExpand || childNodeRendered"
-        v-show="expanded"
-        role="group"
-        :aria-expanded="expanded"
-      >
-        <el-tree-node
-          :render-content="renderContent"
-          v-for="child in node.childNodes"
-          :render-after-expand="renderAfterExpand"
-          :show-checkbox="showCheckbox"
-          :key="getNodeKey(child)"
-          :node="child"
-          @node-expand="handleChildNodeExpand">
-        </el-tree-node>
-      </div>
-    </el-collapse-transition>
-  </div>
-</template>
-
-<script type="text/jsx">
-  import ElCollapseTransition from 'element-ui/src/transitions/collapse-transition';
-  import ElCheckbox from 'element-ui/packages/checkbox';
-  import emitter from 'element-ui/src/mixins/emitter';
-  import { getNodeKey } from './model/util';
-
-  export default {
-    name: 'ElTreeNode',
-
-    componentName: 'ElTreeNode',
-
-    mixins: [emitter],
-
-    props: {
-      node: {
-        default() {
-          return {};
-        }
-      },
-      props: {},
-      renderContent: Function,
-      renderAfterExpand: {
-        type: Boolean,
-        default: true
-      },
-      showCheckbox: {
-        type: Boolean,
-        default: false
-      }
-    },
-
-    components: {
-      ElCollapseTransition,
-      ElCheckbox,
-      NodeContent: {
-        props: {
-          node: {
-            required: true
-          }
-        },
-        render(h) {
-          const parent = this.$parent;
-          const tree = parent.tree;
-          const node = this.node;
-          const { data, store } = node;
-          return (
-            parent.renderContent
-              ? parent.renderContent.call(parent._renderProxy, h, { _self: tree.$vnode.context, node, data, store })
-              : tree.$scopedSlots.default
-                ? tree.$scopedSlots.default({ node, data })
-                : <span class="el-tree-node__label">{ node.label }</span>
-          );
-        }
-      }
-    },
-
-    data() {
-      return {
-        tree: null,
-        expanded: false,
-        childNodeRendered: false,
-        oldChecked: null,
-        oldIndeterminate: null
-      };
-    },
-
-    watch: {
-      'node.indeterminate'(val) {
-        this.handleSelectChange(this.node.checked, val);
-      },
-
-      'node.checked'(val) {
-        this.handleSelectChange(val, this.node.indeterminate);
-      },
-
-      'node.expanded'(val) {
-        this.$nextTick(() => this.expanded = val);
-        if (val) {
-          this.childNodeRendered = true;
-        }
-      }
-    },
-
-    methods: {
-      getNodeKey(node) {
-        return getNodeKey(this.tree.nodeKey, node.data);
-      },
-
-      handleSelectChange(checked, indeterminate) {
-        if (this.oldChecked !== checked && this.oldIndeterminate !== indeterminate) {
-          this.tree.$emit('check-change', this.node.data, checked, indeterminate);
-        }
-        this.oldChecked = checked;
-        this.indeterminate = indeterminate;
-      },
-
-      handleClick() {
-        const store = this.tree.store;
-        store.setCurrentNode(this.node);
-        this.tree.$emit('current-change', store.currentNode ? store.currentNode.data : null, store.currentNode);
-        this.tree.currentNode = this;
-        if (this.tree.expandOnClickNode) {
-          this.handleExpandIconClick();
-        }
-        if (this.tree.checkOnClickNode && !this.node.disabled) {
-          this.handleCheckChange(null, {
-            target: { checked: !this.node.checked }
-          });
-        }
-        this.tree.$emit('node-click', this.node.data, this.node, this);
-      },
-
-      handleContextMenu(event) {
-        if (this.tree._events['node-contextmenu'] && this.tree._events['node-contextmenu'].length > 0) {
-          event.stopPropagation();
-          event.preventDefault();
-        }
-        this.tree.$emit('node-contextmenu', event, this.node.data, this.node, this);
-      },
-
-      handleExpandIconClick() {
-        if (this.node.isLeaf) return;
-        if (this.expanded) {
-          this.tree.$emit('node-collapse', this.node.data, this.node, this);
-          this.node.collapse();
-        } else {
-          this.node.expand();
-          this.$emit('node-expand', this.node.data, this.node, this);
-        }
-      },
-
-      handleCheckChange(value, ev) {
-        this.node.setChecked(ev.target.checked, !this.tree.checkStrictly);
-        this.$nextTick(() => {
-          const store = this.tree.store;
-          this.tree.$emit('check', this.node.data, {
-            checkedNodes: store.getCheckedNodes(),
-            checkedKeys: store.getCheckedKeys(),
-            halfCheckedNodes: store.getHalfCheckedNodes(),
-            halfCheckedKeys: store.getHalfCheckedKeys(),
-          });
-        });
-      },
-
-      handleChildNodeExpand(nodeData, node, instance) {
-        this.broadcast('ElTreeNode', 'tree-node-expand', node);
-        this.tree.$emit('node-expand', nodeData, node, instance);
-      },
-
-      handleDragStart(event) {
-        if (!this.tree.draggable) return;
-        this.tree.$emit('tree-node-drag-start', event, this);
-      },
-
-      handleDragOver(event) {
-        if (!this.tree.draggable) return;
-        this.tree.$emit('tree-node-drag-over', event, this);
-        event.preventDefault();
-      },
-
-      handleDrop(event) {
-        event.preventDefault();
-      },
-
-      handleDragEnd(event) {
-        if (!this.tree.draggable) return;
-        this.tree.$emit('tree-node-drag-end', event, this);
-      }
-    },
-
-    created() {
-      const parent = this.$parent;
-
-      if (parent.isTree) {
-        this.tree = parent;
-      } else {
-        this.tree = parent.tree;
-      }
-
-      const tree = this.tree;
-      if (!tree) {
-        console.warn('Can not find node\'s tree.');
-      }
-
-      const props = tree.props || {};
-      const childrenKey = props['children'] || 'children';
-
-      this.$watch(`node.data.${childrenKey}`, () => {
-        this.node.updateChildren();
-      });
-
-      if (this.node.expanded) {
-        this.expanded = true;
-        this.childNodeRendered = true;
-      }
-
-      if(this.tree.accordion) {
-        this.$on('tree-node-expand', node => {
-          if(this.node !== node) {
-            this.node.collapse();
-          }
-        });
-      }
-    }
-  };
-</script>