vft 0.0.376 → 0.0.378

package/lib/components/tree/model/node.cjs

@@ -1 +1,447 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const v=require("@vft/utils"),D=require("vue"),l=require("./util.cjs"),u=r=>{let e=!0,t=!0,i=!0;for(let s=0,a=r.length;s<a;s++){const d=r[s];(d.checked!==!0||d.indeterminate)&&(e=!1,d.disabled||(i=!1)),(d.checked!==!1||d.indeterminate)&&(t=!1)}return{all:e,none:t,allWithoutDisable:i,half:!e&&!t}},c=function(r){if(r.childNodes.length===0||r.loading)return;const{all:e,none:t,half:i}=u(r.childNodes);e?(r.checked=!0,r.indeterminate=!1):i?(r.checked=!1,r.indeterminate=!0):t&&(r.checked=!1,r.indeterminate=!1);const s=r.parent;!s||s.level===0||r.store.checkStrictly||c(s)},f=function(r,e){const t=r.store.props,i=r.data||{},s=t[e];if(typeof s=="function")return s(i,r);if(typeof s=="string")return i[s];if(typeof s>"u"){const a=i[e];return a===void 0?"":a}};let L=0;class o{id;text;checked;indeterminate;data;expanded;parent;visible;isCurrent;store;isLeafByUser;isLeaf;canFocus;level;loaded;childNodes;loading;constructor(e){this.id=L++,this.text=null,this.checked=!1,this.indeterminate=!1,this.data=null,this.expanded=!1,this.parent=null,this.visible=!0,this.isCurrent=!1,this.canFocus=!1;for(const t in e)v.hasOwn(e,t)&&(this[t]=e[t]);this.level=0,this.loaded=!1,this.childNodes=[],this.loading=!1,this.parent&&(this.level=this.parent.level+1)}initialize(){const e=this.store;if(!e)throw new Error("[Node]store is required!");e.registerNode(this);const t=e.props;if(t&&typeof t.isLeaf<"u"){const a=f(this,"isLeaf");typeof a=="boolean"&&(this.isLeafByUser=a)}if(e.lazy!==!0&&this.data?(this.setData(this.data),e.defaultExpandAll&&(this.expanded=!0,this.canFocus=!0)):this.level>0&&e.lazy&&e.defaultExpandAll&&this.expand(),Array.isArray(this.data)||l.markNodeData(this,this.data),!this.data)return;const i=e.defaultExpandedKeys,s=e.key;s&&i&&i.includes(this.key)&&this.expand(null,e.autoExpandParent),s&&e.currentNodeKey!==void 0&&this.key===e.currentNodeKey&&(e.currentNode=this,e.currentNode.isCurrent=!0),e.lazy&&e._initDefaultCheckedNode(this),this.updateLeafState(),this.parent&&(this.level===1||this.parent.expanded===!0)&&(this.canFocus=!0)}setData(e){Array.isArray(e)||l.markNodeData(this,e),this.data=e,this.childNodes=[];let t;this.level===0&&Array.isArray(this.data)?t=this.data:t=f(this,"children")||[];for(let i=0,s=t.length;i<s;i++)this.insertChild({data:t[i]})}get label(){return f(this,"label")}get key(){const e=this.store.key;return this.data?this.data[e]:null}get disabled(){return f(this,"disabled")}get nextSibling(){const e=this.parent;if(e){const t=e.childNodes.indexOf(this);if(t>-1)return e.childNodes[t+1]}return null}get previousSibling(){const e=this.parent;if(e){const t=e.childNodes.indexOf(this);if(t>-1)return t>0?e.childNodes[t-1]:null}return null}contains(e,t=!0){return(this.childNodes||[]).some(i=>i===e||t&&i.contains(e))}remove(){const e=this.parent;e&&e.removeChild(this)}insertChild(e,t,i){if(!e)throw new Error("InsertChild error: child is required.");if(!(e instanceof o)){if(!i){const s=this.getChildren(!0);s.includes(e.data)||(typeof t>"u"||t<0?s.push(e.data):s.splice(t,0,e.data))}Object.assign(e,{parent:this,store:this.store}),e=D.reactive(new o(e)),e instanceof o&&e.initialize()}e.level=this.level+1,typeof t>"u"||t<0?this.childNodes.push(e):this.childNodes.splice(t,0,e),this.updateLeafState()}updateNode(e){const t=this.parent;if(t){const i=t.childNodes.indexOf(this);t.childNodes[i].data=e}}insertBefore(e,t){let i;t&&(i=this.childNodes.indexOf(t)),this.insertChild(e,i)}insertAfter(e,t){let i;t&&(i=this.childNodes.indexOf(t),i!==-1&&(i+=1)),this.insertChild(e,i)}removeChild(e){const t=this.getChildren()||[],i=t.indexOf(e.data);i>-1&&t.splice(i,1);const s=this.childNodes.indexOf(e);s>-1&&(this.store&&this.store.deregisterNode(e),e.parent=null,this.childNodes.splice(s,1)),this.updateLeafState()}removeChildByData(e){let t=null;for(let i=0;i<this.childNodes.length;i++)if(this.childNodes[i].data===e){t=this.childNodes[i];break}t&&this.removeChild(t)}expand(e,t){const i=()=>{if(t){let s=this.parent;for(;s.level>0;)s.expanded=!0,s=s.parent}this.expanded=!0,e&&e(),this.childNodes.forEach(s=>{s.canFocus=!0})};this.shouldLoadData()?this.loadData(s=>{Array.isArray(s)&&(this.checked?this.setChecked(!0,!0):this.store.checkStrictly||c(this),i())}):i()}doCreateChildren(e,t={}){e.forEach(i=>{this.insertChild(Object.assign({data:i},t),void 0,!0)})}collapse(){this.expanded=!1,this.childNodes.forEach(e=>{e.canFocus=!1})}shouldLoadData(){return this.store.lazy===!0&&this.store.load&&!this.loaded}updateLeafState(){if(this.store.lazy===!0&&this.loaded!==!0&&typeof this.isLeafByUser<"u"){this.isLeaf=this.isLeafByUser;return}const e=this.childNodes;if(!this.store.lazy||this.store.lazy===!0&&this.loaded===!0){this.isLeaf=!e||e.length===0;return}this.isLeaf=!1}setChecked(e,t,i,s){if(this.indeterminate=e==="half",this.checked=e===!0,this.store.checkStrictly)return;if(!(this.shouldLoadData()&&!this.store.checkDescendants)){const{all:d,allWithoutDisable:n}=u(this.childNodes);!this.isLeaf&&!d&&n&&(this.checked=!1,e=!1);const p=()=>{if(t){const h=this.childNodes;for(let y=0,k=h.length;y<k;y++){const N=h[y];s=s||e!==!1;const x=N.disabled?N.checked:s;N.setChecked(x,t,!0,s)}const{half:C,all:g}=u(h);g||(this.checked=g,this.indeterminate=C)}};if(this.shouldLoadData()){this.loadData(()=>{p(),c(this)},{checked:e!==!1});return}else p()}const a=this.parent;!a||a.level===0||i||c(a)}getChildren(e=!1){if(this.level===0)return this.data;const t=this.data;if(!t)return null;const i=this.store.props;let s="children";return i&&(s=i.children||"children"),t[s]===void 0&&(t[s]=null),e&&!t[s]&&(t[s]=[]),t[s]}updateChildren(){const e=this.getChildren()||[],t=this.childNodes.map(a=>a.data),i={},s=[];e.forEach((a,d)=>{const n=a[l.NODE_KEY];!!n&&t.findIndex(h=>h[l.NODE_KEY]===n)>=0?i[n]={index:d,data:a}:s.push({index:d,data:a})}),this.store.lazy||t.forEach(a=>{i[a[l.NODE_KEY]]||this.removeChildByData(a)}),s.forEach(({index:a,data:d})=>{this.insertChild({data:d},a)}),this.updateLeafState()}loadData(e,t={}){if(this.store.lazy===!0&&this.store.load&&!this.loaded&&(!this.loading||Object.keys(t).length)){this.loading=!0;const i=s=>{this.childNodes=[],this.doCreateChildren(s,t),this.loaded=!0,this.loading=!1,this.updateLeafState(),e&&e.call(this,s)};this.store.load(this,i)}else e&&e.call(this)}}exports.default=o;exports.getChildState=u;
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const utils = require("@vft/utils");
+const vue = require("vue");
+const util = require("./util.cjs");
+const getChildState = (node) => {
+  let all = true;
+  let none = true;
+  let allWithoutDisable = true;
+  for (let i = 0, j = node.length; i < j; i++) {
+    const n = node[i];
+    if (n.checked !== true || n.indeterminate) {
+      all = false;
+      if (!n.disabled) {
+        allWithoutDisable = false;
+      }
+    }
+    if (n.checked !== false || n.indeterminate) {
+      none = false;
+    }
+  }
+  return { all, none, allWithoutDisable, half: !all && !none };
+};
+const reInitChecked = function(node) {
+  if (node.childNodes.length === 0 || node.loading) return;
+  const { all, none, half } = getChildState(node.childNodes);
+  if (all) {
+    node.checked = true;
+    node.indeterminate = false;
+  } else if (half) {
+    node.checked = false;
+    node.indeterminate = true;
+  } else if (none) {
+    node.checked = false;
+    node.indeterminate = false;
+  }
+  const parent = node.parent;
+  if (!parent || parent.level === 0) return;
+  if (!node.store.checkStrictly) {
+    reInitChecked(parent);
+  }
+};
+const getPropertyFromData = function(node, prop) {
+  const props = node.store.props;
+  const data = node.data || {};
+  const config = props[prop];
+  if (typeof config === "function") {
+    return config(data, node);
+  } else if (typeof config === "string") {
+    return data[config];
+  } else if (typeof config === "undefined") {
+    const dataProp = data[prop];
+    return dataProp === void 0 ? "" : dataProp;
+  }
+};
+let nodeIdSeed = 0;
+class Node {
+  id;
+  text;
+  checked;
+  indeterminate;
+  data;
+  expanded;
+  parent;
+  visible;
+  isCurrent;
+  store;
+  isLeafByUser;
+  isLeaf;
+  canFocus;
+  level;
+  loaded;
+  childNodes;
+  loading;
+  constructor(options) {
+    this.id = nodeIdSeed++;
+    this.text = null;
+    this.checked = false;
+    this.indeterminate = false;
+    this.data = null;
+    this.expanded = false;
+    this.parent = null;
+    this.visible = true;
+    this.isCurrent = false;
+    this.canFocus = false;
+    for (const name in options) {
+      if (utils.hasOwn(options, name)) {
+        this[name] = options[name];
+      }
+    }
+    this.level = 0;
+    this.loaded = false;
+    this.childNodes = [];
+    this.loading = false;
+    if (this.parent) {
+      this.level = this.parent.level + 1;
+    }
+  }
+  initialize() {
+    const store = this.store;
+    if (!store) {
+      throw new Error("[Node]store is required!");
+    }
+    store.registerNode(this);
+    const props = store.props;
+    if (props && typeof props.isLeaf !== "undefined") {
+      const isLeaf = getPropertyFromData(this, "isLeaf");
+      if (typeof isLeaf === "boolean") {
+        this.isLeafByUser = isLeaf;
+      }
+    }
+    if (store.lazy !== true && this.data) {
+      this.setData(this.data);
+      if (store.defaultExpandAll) {
+        this.expanded = true;
+        this.canFocus = true;
+      }
+    } else if (this.level > 0 && store.lazy && store.defaultExpandAll) {
+      this.expand();
+    }
+    if (!Array.isArray(this.data)) {
+      util.markNodeData(this, this.data);
+    }
+    if (!this.data) return;
+    const defaultExpandedKeys = store.defaultExpandedKeys;
+    const key = store.key;
+    if (key && defaultExpandedKeys && defaultExpandedKeys.includes(this.key)) {
+      this.expand(null, store.autoExpandParent);
+    }
+    if (key && store.currentNodeKey !== void 0 && this.key === store.currentNodeKey) {
+      store.currentNode = this;
+      store.currentNode.isCurrent = true;
+    }
+    if (store.lazy) {
+      store._initDefaultCheckedNode(this);
+    }
+    this.updateLeafState();
+    if (this.parent && (this.level === 1 || this.parent.expanded === true))
+      this.canFocus = true;
+  }
+  setData(data) {
+    if (!Array.isArray(data)) {
+      util.markNodeData(this, data);
+    }
+    this.data = data;
+    this.childNodes = [];
+    let children;
+    if (this.level === 0 && Array.isArray(this.data)) {
+      children = this.data;
+    } else {
+      children = getPropertyFromData(this, "children") || [];
+    }
+    for (let i = 0, j = children.length; i < j; i++) {
+      this.insertChild({ data: children[i] });
+    }
+  }
+  get label() {
+    return getPropertyFromData(this, "label");
+  }
+  get key() {
+    const nodeKey = this.store.key;
+    if (this.data) return this.data[nodeKey];
+    return null;
+  }
+  get disabled() {
+    return getPropertyFromData(this, "disabled");
+  }
+  get nextSibling() {
+    const parent = this.parent;
+    if (parent) {
+      const index = parent.childNodes.indexOf(this);
+      if (index > -1) {
+        return parent.childNodes[index + 1];
+      }
+    }
+    return null;
+  }
+  get previousSibling() {
+    const parent = this.parent;
+    if (parent) {
+      const index = parent.childNodes.indexOf(this);
+      if (index > -1) {
+        return index > 0 ? parent.childNodes[index - 1] : null;
+      }
+    }
+    return null;
+  }
+  contains(target, deep = true) {
+    return (this.childNodes || []).some(
+      (child) => child === target || deep && child.contains(target)
+    );
+  }
+  remove() {
+    const parent = this.parent;
+    if (parent) {
+      parent.removeChild(this);
+    }
+  }
+  insertChild(child, index, batch) {
+    if (!child) throw new Error("InsertChild error: child is required.");
+    if (!(child instanceof Node)) {
+      if (!batch) {
+        const children = this.getChildren(true);
+        if (!children.includes(child.data)) {
+          if (typeof index === "undefined" || index < 0) {
+            children.push(child.data);
+          } else {
+            children.splice(index, 0, child.data);
+          }
+        }
+      }
+      Object.assign(child, {
+        parent: this,
+        store: this.store
+      });
+      child = vue.reactive(new Node(child));
+      if (child instanceof Node) {
+        child.initialize();
+      }
+    }
+    child.level = this.level + 1;
+    if (typeof index === "undefined" || index < 0) {
+      this.childNodes.push(child);
+    } else {
+      this.childNodes.splice(index, 0, child);
+    }
+    this.updateLeafState();
+  }
+  updateNode(data) {
+    const parent = this.parent;
+    if (parent) {
+      const index = parent.childNodes.indexOf(this);
+      parent.childNodes[index].data = data;
+    }
+  }
+  insertBefore(child, ref) {
+    let index;
+    if (ref) {
+      index = this.childNodes.indexOf(ref);
+    }
+    this.insertChild(child, index);
+  }
+  insertAfter(child, ref) {
+    let index;
+    if (ref) {
+      index = this.childNodes.indexOf(ref);
+      if (index !== -1) index += 1;
+    }
+    this.insertChild(child, index);
+  }
+  removeChild(child) {
+    const children = this.getChildren() || [];
+    const dataIndex = children.indexOf(child.data);
+    if (dataIndex > -1) {
+      children.splice(dataIndex, 1);
+    }
+    const index = this.childNodes.indexOf(child);
+    if (index > -1) {
+      this.store && this.store.deregisterNode(child);
+      child.parent = null;
+      this.childNodes.splice(index, 1);
+    }
+    this.updateLeafState();
+  }
+  removeChildByData(data) {
+    let targetNode = null;
+    for (let i = 0; i < this.childNodes.length; i++) {
+      if (this.childNodes[i].data === data) {
+        targetNode = this.childNodes[i];
+        break;
+      }
+    }
+    if (targetNode) {
+      this.removeChild(targetNode);
+    }
+  }
+  expand(callback, expandParent) {
+    const done = () => {
+      if (expandParent) {
+        let parent = this.parent;
+        while (parent.level > 0) {
+          parent.expanded = true;
+          parent = parent.parent;
+        }
+      }
+      this.expanded = true;
+      if (callback) callback();
+      this.childNodes.forEach((item) => {
+        item.canFocus = true;
+      });
+    };
+    if (this.shouldLoadData()) {
+      this.loadData((data) => {
+        if (Array.isArray(data)) {
+          if (this.checked) {
+            this.setChecked(true, true);
+          } else if (!this.store.checkStrictly) {
+            reInitChecked(this);
+          }
+          done();
+        }
+      });
+    } else {
+      done();
+    }
+  }
+  doCreateChildren(array, defaultProps = {}) {
+    array.forEach((item) => {
+      this.insertChild(
+        Object.assign({ data: item }, defaultProps),
+        void 0,
+        true
+      );
+    });
+  }
+  collapse() {
+    this.expanded = false;
+    this.childNodes.forEach((item) => {
+      item.canFocus = false;
+    });
+  }
+  shouldLoadData() {
+    return this.store.lazy === true && this.store.load && !this.loaded;
+  }
+  updateLeafState() {
+    if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== "undefined") {
+      this.isLeaf = this.isLeafByUser;
+      return;
+    }
+    const childNodes = this.childNodes;
+    if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
+      this.isLeaf = !childNodes || childNodes.length === 0;
+      return;
+    }
+    this.isLeaf = false;
+  }
+  setChecked(value, deep, recursion, passValue) {
+    this.indeterminate = value === "half";
+    this.checked = value === true;
+    if (this.store.checkStrictly) return;
+    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+      const { all, allWithoutDisable } = getChildState(this.childNodes);
+      if (!this.isLeaf && !all && allWithoutDisable) {
+        this.checked = false;
+        value = false;
+      }
+      const handleDescendants = () => {
+        if (deep) {
+          const childNodes = this.childNodes;
+          for (let i = 0, j = childNodes.length; i < j; i++) {
+            const child = childNodes[i];
+            passValue = passValue || value !== false;
+            const isCheck = child.disabled ? child.checked : passValue;
+            child.setChecked(isCheck, deep, true, passValue);
+          }
+          const { half, all: all2 } = getChildState(childNodes);
+          if (!all2) {
+            this.checked = all2;
+            this.indeterminate = half;
+          }
+        }
+      };
+      if (this.shouldLoadData()) {
+        this.loadData(
+          () => {
+            handleDescendants();
+            reInitChecked(this);
+          },
+          {
+            checked: value !== false
+          }
+        );
+        return;
+      } else {
+        handleDescendants();
+      }
+    }
+    const parent = this.parent;
+    if (!parent || parent.level === 0) return;
+    if (!recursion) {
+      reInitChecked(parent);
+    }
+  }
+  getChildren(forceInit = false) {
+    if (this.level === 0) return this.data;
+    const data = this.data;
+    if (!data) return null;
+    const props = this.store.props;
+    let children = "children";
+    if (props) {
+      children = props.children || "children";
+    }
+    if (data[children] === void 0) {
+      data[children] = null;
+    }
+    if (forceInit && !data[children]) {
+      data[children] = [];
+    }
+    return data[children];
+  }
+  updateChildren() {
+    const newData = this.getChildren() || [];
+    const oldData = this.childNodes.map((node) => node.data);
+    const newDataMap = {};
+    const newNodes = [];
+    newData.forEach((item, index) => {
+      const key = item[util.NODE_KEY];
+      const isNodeExists = !!key && oldData.findIndex((data) => data[util.NODE_KEY] === key) >= 0;
+      if (isNodeExists) {
+        newDataMap[key] = { index, data: item };
+      } else {
+        newNodes.push({ index, data: item });
+      }
+    });
+    if (!this.store.lazy) {
+      oldData.forEach((item) => {
+        if (!newDataMap[item[util.NODE_KEY]]) this.removeChildByData(item);
+      });
+    }
+    newNodes.forEach(({ index, data }) => {
+      this.insertChild({ data }, index);
+    });
+    this.updateLeafState();
+  }
+  loadData(callback, defaultProps = {}) {
+    if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
+      this.loading = true;
+      const resolve = (children) => {
+        this.childNodes = [];
+        this.doCreateChildren(children, defaultProps);
+        this.loaded = true;
+        this.loading = false;
+        this.updateLeafState();
+        if (callback) {
+          callback.call(this, children);
+        }
+      };
+      this.store.load(this, resolve);
+    } else {
+      if (callback) {
+        callback.call(this);
+      }
+    }
+  }
+}
+exports.default = Node;
+exports.getChildState = getChildState;