单独构建大屏ui库,避免引入混乱

ui/dv/AiOkrTree/model/tree-store.js

@@ -0,0 +1,177 @@
+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
+      },
+      false
+    );
+
+    if (this.root.store.onlyBothTree) {
+      if (!this.leftData)
+        throw new Error("[Tree] leftData is required in onlyBothTree");
+      if (this.leftData) {
+        this.isLeftChilds = new Node(
+          {
+            data: this.leftData,
+            store: this
+          },
+          true
+        );
+        if (this.isLeftChilds) {
+          this.root.childNodes[0].leftChildNodes = this.isLeftChilds.childNodes[0].childNodes;
+          this.root.childNodes[0].leftExpanded = this.isLeftChilds.childNodes[0].leftExpanded;
+        }
+      }
+    }
+  }
+  filter(value, childName = "childNodes") {
+    this.filterRight(value, childName);
+  }
+  // 过滤默认节点
+  filterRight(value, childName) {
+    const filterNodeMethod = this.filterNodeMethod;
+    const traverse = function(node, childName) {
+      let childNodes;
+      if (node.root) {
+        childNodes = node.root.childNodes[0][childName];
+      } else {
+        childNodes = node.childNodes;
+      }
+      childNodes.forEach(child => {
+        child.visible = filterNodeMethod.call(child, value, child.data, child);
+        traverse(child, childName);
+      });
+
+      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.expand();
+    };
+
+    traverse(this, childName);
+  }
+
+  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];
+  }
+  setData(newVal) {
+    const instanceChanged = newVal !== this.root.data;
+    if (instanceChanged) {
+      this.root.setData(newVal);
+    } else {
+      this.root.updateChildren();
+    }
+  }
+  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);
+    }
+  }
+  getNode(data) {
+    if (data instanceof Node) return data;
+    const key = typeof data !== "object" ? data : getNodeKey(this.key, data);
+    return this.nodesMap[key] || null;
+  }
+  setDefaultExpandedKeys(keys) {
+    keys = keys || [];
+    this.defaultExpandedKeys = keys;
+    keys.forEach(key => {
+      const node = this.getNode(key);
+      if (node) node.expand(null, true);
+    });
+  }
+  setCurrentNode(currentNode) {
+    const prevCurrentNode = this.currentNode;
+    if (prevCurrentNode) {
+      prevCurrentNode.isCurrent = false;
+    }
+    this.currentNode = currentNode;
+    this.currentNode.isCurrent = true;
+  }
+  setUserCurrentNode(node) {
+    const key = node.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);
+    }
+  }
+  getCurrentNode() {
+    return this.currentNode;
+  }
+  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 });
+    }
+  }
+  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);
+  }
+}