@unicom-cloud/ui 0.8.67 → 0.8.68

package/tree/Tree.js

@@ -0,0 +1,580 @@
+import { jsx as ce } from "react/jsx-runtime";
+import { forwardRef as Oe, useContext as Se, useRef as O, useState as ve, useImperativeHandle as Te, useEffect as F, createElement as Ae } from "react";
+import { G as Ie } from "../chunk/URXCKjXr.js";
+import b from "lodash/get";
+import z from "lodash/has";
+import Me from "lodash/isArray";
+import D from "lodash/isEqualWith";
+import He from "lodash/isFunction";
+import re from "lodash/isUndefined";
+import { a as $e } from "../chunk/ll867Bf3.js";
+import { m as se } from "../chunk/JPPo5nY_.js";
+import { a as We } from "../chunk/ClqoGc3r.js";
+import { TreeContext as Re } from "./Context.js";
+import { N as le } from "../chunk/CKyu68pu.js";
+import je from "./NodeList.js";
+import { getTreeDataFromTreeChildren as Fe, getCheckedKeysByInitKeys as ze, getAllCheckedKeysByCheck as qe } from "./util.js";
+const de = {
+  key: "key",
+  title: "title",
+  children: "children",
+  selectable: "selectable",
+  disabled: "disabled",
+  disableCheckbox: "disableCheckbox",
+  checkable: "checkable",
+  isLeaf: "isLeaf"
+}, ie = "parent", oe = "all", ae = "child", Be = {
+  selectable: !0,
+  autoExpandParent: !0,
+  checkedStrategy: oe,
+  actionOnClick: "select",
+  allowDrop: () => !0,
+  fieldNames: de,
+  animation: !0
+}, Ue = [
+  "style",
+  "className",
+  "height",
+  "size",
+  "blockNode",
+  "autoExpandParent",
+  "checkedStrategy",
+  "fieldNames",
+  "icons",
+  "virtualListProps",
+  "showLine",
+  "selectable",
+  "allowDrop",
+  "actionOnClick",
+  "animation"
+];
+function Ve(s, ye) {
+  const w = Se($e), q = O(null), h = O({}), N = O(), v = O(), I = O(), [o, x] = ve(() => {
+    const e = M(), c = H(e, w.getPrefixCls("tree")), { checkedKeys: n, halfCheckedKeys: t } = $(
+      s.checkedKeys || s.defaultCheckedKeys || []
+    );
+    return {
+      selectedKeys: s.selectedKeys || s.defaultSelectedKeys || [],
+      checkedKeys: n,
+      halfCheckedKeys: t,
+      expandedKeys: U(
+        s.expandedKeys || s.defaultExpandedKeys
+      ),
+      loadedKeys: [],
+      loadingKeys: [],
+      currentExpandKeys: [],
+      nodeList: c
+    };
+  });
+  function g(e) {
+    const { componentConfig: c } = w ?? {}, n = e || s, t = (c == null ? void 0 : c.Tree) || {}, l = {};
+    return Ue.forEach((r) => {
+      re(n[r]) ? re(t[r]) ? l[r] = Be[r] : l[r] = t[r] : l[r] = n[r];
+    }), l;
+  }
+  function fe(e, c) {
+    let n = e;
+    c && (n = c._key), I.current && I.current.scrollIntoView(
+      n,
+      c || h.current[n]
+    );
+  }
+  function M() {
+    return "treeData" in s ? s.treeData : Fe(s.children);
+  }
+  function ue(e, c) {
+    const n = [
+      "fieldNames",
+      "selectable",
+      "draggable",
+      "checkStrictly",
+      "showLine",
+      "blockNode",
+      "checkable",
+      "treeData",
+      "children"
+    ];
+    return e.treeData !== c.treeData || e.children !== c.children || n.some((t) => D(e[t], c[t]));
+  }
+  function B(e) {
+    const c = g(), { selectable: n } = c, t = {
+      ...de,
+      ..."treeData" in s ? c.fieldNames : {}
+    }, l = {
+      children: b(e, t.children),
+      selectable: z(e, t.selectable) ? b(e, t.selectable) : n,
+      checkable: z(e, t.checkable) ? b(e, t.checkable) : s.checkable,
+      title: b(e, t.title),
+      disabled: b(e, t.disabled),
+      disableCheckbox: b(e, t.disableCheckbox),
+      isLeaf: b(e, t.isLeaf),
+      key: b(e, t.key)
+    };
+    return z(e, t.key) || delete l.key, l;
+  }
+  function H(e, c) {
+    h.current = {};
+    const n = c || w.getPrefixCls("tree"), t = [];
+    let l = 0;
+    const { showLine: r, blockNode: i } = g(), d = (y, a) => {
+      const m = y.length;
+      return y.map((k, f) => {
+        const {
+          children: C,
+          selectable: u,
+          checkable: E,
+          key: _ = `${(a == null ? void 0 : a._key) || ""}-${f}`,
+          ...j
+        } = B(k), L = {
+          // data 中含有dataRef时，优先级较高
+          dataRef: k,
+          draggable: s.draggable,
+          selectable: u,
+          checkable: E,
+          showLine: r,
+          blockNode: i,
+          ...k,
+          ...j,
+          key: _,
+          children: C,
+          _key: _,
+          _index: l++,
+          parentKey: a ? a._key : void 0,
+          pathParentKeys: a && a.pathParentKeys || [],
+          _level: a._level || 0,
+          // 保存node在sowLine模式下是否显示缩进线。如果父节点是其所在层级的最后一个节点，那么所有的子节点（包括孙子节点等）在父节点所在层级的缩进格都不显示缩进线。
+          _lineless: a && a._lineless ? [...a._lineless || [], a._isTail] : []
+        };
+        return m === f + 1 && (L.className = se(
+          `${n}-node-is-tail`,
+          L.className
+        )), t.push(L), h.current[_] = L, C && C.length && (h.current[_].children = d(C, {
+          _key: _,
+          _level: L._level + 1,
+          _lineless: L._lineless,
+          _isTail: m === f + 1,
+          pathParentKeys: [...(a == null ? void 0 : a.pathParentKeys) || [], _]
+        })), L;
+      });
+    };
+    return d(e || [], {}), t;
+  }
+  function U(e) {
+    if (!g().autoExpandParent)
+      return e || [];
+    if (!e)
+      return Object.keys(h.current).filter((n) => {
+        const t = h.current[n];
+        return t.children && t.children.length;
+      });
+    const c = {};
+    return e.forEach((n) => {
+      const t = h.current[n];
+      t && (c[n] = 1, t.pathParentKeys && t.pathParentKeys.forEach((l) => {
+        c[l] = 1;
+      }));
+    }), Object.keys(c);
+  }
+  function $(e) {
+    if (!s.checkStrictly) {
+      const { checkedKeys: c, indeterminateKeys: n } = ze(
+        e,
+        h.current
+      );
+      return {
+        checkedKeys: c,
+        halfCheckedKeys: n
+      };
+    }
+    return {
+      checkedKeys: e,
+      halfCheckedKeys: s.halfCheckedKeys || []
+    };
+  }
+  function he(e, c) {
+    const { onSelect: n } = s, t = { e: c, node: K([e])[0] };
+    if (s.multiple) {
+      const l = [...o.selectedKeys], r = l.indexOf(e);
+      r > -1 ? (l.splice(r, 1), t.selected = !1) : (t.selected = !0, l.push(e)), t.selectedNodes = K(l), "selectedKeys" in s || x((i) => {
+        const d = { ...i };
+        return d.selectedKeys = l, d;
+      }), n == null || n(l, t);
+    } else
+      t.selected = !0, t.selectedNodes = K([e]), "selectedKeys" in s || x((l) => {
+        const r = { ...l };
+        return r.selectedKeys = [e], r;
+      }), n == null || n([e], t);
+  }
+  function V(e, c, n) {
+    const { checkedStrategy: t } = g(), { onCheck: l, checkStrictly: r } = s, i = { e: n, node: K([c])[0] };
+    let d = [...o.checkedKeys || []], y = o.halfCheckedKeys;
+    if (r) {
+      e ? d = d.concat(c) : d = d.filter((m) => m !== c);
+      const a = {};
+      "checkedKeys" in s || (a.checkedKeys = d), "halfCheckedKeys" in s || (a.halfCheckedKeys = y), Ie(a) || x((m) => ({ ...m, ...a }));
+    } else {
+      const { checkedKeys: a, indeterminateKeys: m } = qe(
+        c,
+        e,
+        d,
+        h.current,
+        y
+      );
+      d = a, y = m, "checkedKeys" in s ? x((k) => {
+        const f = { ...k };
+        return f.halfCheckedKeys = y, f;
+      }) : x((k) => {
+        const f = { ...k };
+        return f.checkedKeys = d, f.halfCheckedKeys = y, f;
+      }), t === ie ? d = d.filter((k) => {
+        const f = h.current[k];
+        if (!f || d.indexOf(f.parentKey) === -1)
+          return !0;
+      }) : t === ae && (d = d.filter((k) => {
+        var C, u;
+        const f = h.current[k];
+        if (!f || !((C = f.children) != null && C.length) || (u = f.children) != null && u.every((E) => d.indexOf(E._key) === -1))
+          return !0;
+      }));
+    }
+    l == null || l(d, {
+      checkedNodes: K(d),
+      checked: e,
+      halfCheckedKeys: y,
+      halfCheckedNodes: K(y),
+      ...i
+    });
+  }
+  function Ke(e) {
+    if (He(s.loadMore)) {
+      const { loadingKeys: c = [], loadedKeys: n } = o;
+      x((t) => {
+        const l = { ...t };
+        return l.loadingKeys = Array.from(/* @__PURE__ */ new Set([...c, e._key])), l.loadedKeys = n.filter((r) => r !== e._key), l;
+      }), A == null || A(K([e._key])[0]).then((t) => {
+        x((l) => {
+          const r = { ...l };
+          return r.loadingKeys = l.loadingKeys.filter((i) => i !== e._key), r.loadedKeys = Array.from(/* @__PURE__ */ new Set([...l.loadedKeys, e._key])), r;
+        }), W(!e.expanded, e._key);
+      }).catch((t) => {
+        x((l) => {
+          const r = { ...l };
+          return r.loadingKeys = l.loadingKeys.filter((i) => i !== e._key), r;
+        }), console.error("[tree]load data error: ", t);
+      }).finally(() => {
+      });
+    }
+  }
+  function ke(e, c) {
+    N.current = K([c._key])[0], v.current = 0;
+    const { onDragStart: n } = s;
+    n == null || n(e, K([c._key])[0]);
+  }
+  function xe(e, c) {
+    N.current = null, v.current = 0;
+    const { onDragEnd: n } = s;
+    n == null || n(e, K([c._key])[0]);
+  }
+  function me(e, c, n) {
+    v.current = n;
+    const { onDragOver: t } = s;
+    t == null || t(e, K([c._key])[0]);
+  }
+  function ge(e, c) {
+    v.current = 0;
+    const { onDragLeave: n } = s;
+    n == null || n(e, K([c._key])[0]);
+  }
+  function Ce(e, c) {
+    let n = h.current[e.parentKey];
+    for (; n; ) {
+      const { _key: t, parentKey: l } = n;
+      if (t === c.props._key)
+        return !0;
+      if (l === t)
+        return;
+      n = h.current[l];
+    }
+  }
+  function G(e, c) {
+    if (e === void 0 || c === void 0)
+      return !1;
+    if (e === c)
+      return !0;
+    const n = e.key, t = c.key;
+    if (n !== void 0 || t !== void 0)
+      return n === t;
+    const l = e.props._key, r = c.props._key;
+    return l === void 0 && r === void 0 ? !1 : l === r;
+  }
+  function J(e, c, n) {
+    if (N.current) {
+      const { allowDrop: t } = g(), { onDrop: l } = s, r = K([c._key])[0];
+      if (l && !Ce(c, N.current) && !G(N.current, r)) {
+        if (t && !t({
+          dropNode: r,
+          dragNode: N.current,
+          dropPosition: n
+        }))
+          return;
+        l({
+          dragNode: N.current,
+          dropNode: r,
+          dropPosition: n,
+          e
+        });
+      }
+    }
+  }
+  function Q(e, c) {
+    const { allowDrop: n } = g();
+    let t = !0;
+    return typeof n == "function" && (t = n({
+      dropNode: K([e._key])[0],
+      dragNode: N.current,
+      dropPosition: c
+    })), t;
+  }
+  function W(e, c) {
+    const { currentExpandKeys: n, expandedKeys: t = [] } = o, { animation: l } = g(), { onExpand: r } = s;
+    if (n.indexOf(c) > -1)
+      return;
+    let i = [];
+    e ? i = Array.from(/* @__PURE__ */ new Set([...t, c])) : i = t.filter((d) => d !== c), "expandedKeys" in s || x((d) => {
+      const y = { ...d };
+      return y.expandedKeys = i, y.currentExpandKeys = l ? [...n, c] : [], y;
+    }), r == null || r(i, {
+      expanded: e,
+      node: K([c])[0],
+      expandedNodes: K(i)
+    });
+  }
+  function K(e) {
+    const { __PqbAdapterMode__: c } = s, n = [];
+    return [].concat(e).forEach((l) => {
+      const r = h.current[l];
+      r && n.push(r);
+    }), T(n).map((l) => c ? {
+      props: l,
+      key: e
+    } : /* @__PURE__ */ Ae(le, { ...l, key: l.key }));
+  }
+  function R(e) {
+    return {
+      expandedKeysSet: (e == null ? void 0 : e.expandedKeysSet) || new Set((o == null ? void 0 : o.expandedKeys) || []),
+      checkedKeysSet: (e == null ? void 0 : e.checkedKeysSet) || new Set((o == null ? void 0 : o.checkedKeys) || []),
+      selectedKeysSet: (e == null ? void 0 : e.selectedKeysSet) || new Set((o == null ? void 0 : o.selectedKeys) || []),
+      halfCheckedKeysSet: (e == null ? void 0 : e.halfCheckedKeysSet) || new Set((o == null ? void 0 : o.halfCheckedKeys) || [])
+    };
+  }
+  function T(e, c) {
+    const { autoExpandParent: n } = g(), { loadMore: t } = s, {
+      selectedKeys: l,
+      expandedKeys: r,
+      checkedKeys: i,
+      loadingKeys: d = [],
+      loadedKeys: y = []
+    } = o, {
+      expandedKeysSet: a,
+      checkedKeysSet: m,
+      selectedKeysSet: k,
+      halfCheckedKeysSet: f
+    } = R(c), C = (u) => {
+      const E = u.children && u.children.length, _ = {
+        isLeaf: !E,
+        autoExpandParent: E ? n : !1,
+        expanded: a ? a.has(u._key) : r.indexOf(u._key) > -1
+      };
+      if (t) {
+        const j = y.indexOf(u._key) > -1;
+        _.loaded = j, _.isLeaf = E ? !1 : u.isLeaf;
+      }
+      return {
+        ...u,
+        ..._,
+        selected: k.has(u._key),
+        indeterminated: f.has(u._key),
+        loading: d.indexOf(u._key) > -1,
+        checked: m.has(u._key),
+        selectedKeys: l,
+        checkedKeys: i,
+        loadingKeys: d,
+        loadedKeys: y,
+        expandedKeys: r,
+        childrenData: u.children || [],
+        children: null
+      };
+    };
+    return Me(e) ? e.map((u) => C(u)) : C(e);
+  }
+  function X(e) {
+    x((c) => {
+      const n = { ...c }, { currentExpandKeys: t } = c;
+      return t.indexOf(e) > -1 && (n.currentExpandKeys = t.filter((l) => l !== e)), n;
+    });
+  }
+  function Y() {
+    return o;
+  }
+  Te(ye, () => ({
+    scrollIntoView: fe,
+    handleCheck: V,
+    getTreeState: Y,
+    handleExpandEnd: X,
+    getNodeProps: T,
+    getDataSet: R,
+    getCacheNode: K,
+    handleExpand: W,
+    handleAllowDrop: Q,
+    handleNodeDrop: J,
+    isSameNode: G
+  })), F(() => {
+    const e = q.current, c = g(e), n = g();
+    if (e !== s || !D(c, n)) {
+      const t = {};
+      if (ue(
+        { prevMergedProps: c, ...e },
+        { ...n, ...s }
+      )) {
+        const r = M(), i = H(r);
+        t.treeData = r, t.nodeList = i;
+      }
+      if (t.treeData || "checkedKeys" in s && !D(e == null ? void 0 : e.checkedKeys, s.checkedKeys)) {
+        const r = "checkedKeys" in s ? s.checkedKeys : o.checkedKeys, { halfCheckedKeys: i, checkedKeys: d } = $(
+          r || []
+        );
+        D(d, o.checkedKeys) || (t.checkedKeys = d), D(i, o.halfCheckedKeys) || (t.halfCheckedKeys = i);
+      }
+      s.checkStrictly && "halfCheckedKeys" in s && !D(e == null ? void 0 : e.halfCheckedKeys, s.halfCheckedKeys) && (t.halfCheckedKeys = s.halfCheckedKeys), "expandedKeys" in s && !D(s.expandedKeys, e == null ? void 0 : e.expandedKeys) && (t.expandedKeys = s.expandedKeys, t.currentExpandKeys = n.animation ? [...t.expandedKeys ?? [], ...o.expandedKeys ?? []].reduce((r, i) => {
+        const d = r.indexOf(i);
+        return d === -1 ? r.push(i) : r.splice(d, 1), r;
+      }, []).filter((r, i, d) => {
+        var y;
+        if (h.current[r])
+          return h.current[r].pathParentKeys.some((m) => d.indexOf(m) > -1) ? !1 : (y = h.current[r].children) == null ? void 0 : y.length;
+      }) : []);
+      const l = t.currentExpandKeys || o.currentExpandKeys;
+      t.treeData && l && (t.currentExpandKeys = l.filter((r) => {
+        const i = t.treeData.find((d) => d.key === r);
+        return i && i.children && i.children.length;
+      })), Object.keys(t).length && x((r) => ({ ...r, ...t }));
+    }
+    return q.current = s, () => {
+    };
+  }), F(() => ("selectedKeys" in s && !D(s.selectedKeys, o.selectedKeys) && x((e) => {
+    const c = { ...e };
+    return c.selectedKeys = s.selectedKeys || [], c;
+  }), () => {
+  }), [s.selectedKeys, o.selectedKeys]), F(() => {
+    const e = M(), c = H(e, w.getPrefixCls("tree")), { checkedKeys: n, halfCheckedKeys: t } = $(
+      s.checkedKeys || s.defaultCheckedKeys || []
+    );
+    return x((l) => {
+      let r = { ...l };
+      return r = {
+        ...r,
+        selectedKeys: s.selectedKeys || s.defaultSelectedKeys || [],
+        checkedKeys: n,
+        halfCheckedKeys: t,
+        expandedKeys: U(
+          s.expandedKeys || s.defaultExpandedKeys
+        ),
+        loadedKeys: [],
+        loadingKeys: [],
+        currentExpandKeys: [],
+        nodeList: c
+      }, r;
+    }), () => {
+    };
+  }, []);
+  const {
+    className: _e,
+    showLine: Ne,
+    size: Z,
+    virtualListProps: p,
+    height: ee,
+    style: be,
+    icons: De,
+    actionOnClick: Ee,
+    animation: te
+  } = g(), { loadMore: A, checkable: Le } = s, ne = p ? {
+    threshold: 100,
+    ...p
+  } : ee ? { height: ee, threshold: 100 } : {
+    threshold: null
+  }, { getPrefixCls: we, rtl: Pe } = w, P = we("tree");
+  return /* @__PURE__ */ ce(
+    Re.Provider,
+    {
+      value: {
+        icons: De,
+        animation: te,
+        key2nodeProps: h.current,
+        getFieldInfo: B,
+        getTreeState: Y,
+        getNodeProps: T,
+        onExpandEnd: te ? X : () => {
+        },
+        onSelect: he,
+        onCheck: V,
+        onNodeDragStart: ke,
+        onNodeDragEnd: xe,
+        onNodeDragLeave: ge,
+        onNodeDragOver: me,
+        onNodeDrop: J,
+        onExpand: W,
+        renderExtra: s.renderExtra,
+        renderTitle: s.renderTitle,
+        loadMore: A && Ke,
+        allowDrop: Q,
+        actionOnClick: Ee,
+        virtualListProps: ne
+      },
+      children: /* @__PURE__ */ ce(
+        je,
+        {
+          ref: (e) => {
+            I.current = e;
+          },
+          className: se(
+            P,
+            {
+              [`${P}-checkable`]: Le,
+              [`${P}-show-line`]: Ne,
+              [`${P}-size-${Z}`]: Z,
+              [`${P}-rtl`]: Pe
+            },
+            _e
+          ),
+          style: be,
+          filterNode: s.filterNode,
+          virtualListProps: ne,
+          expandedKeys: o.expandedKeys,
+          currentExpandKeys: o.currentExpandKeys,
+          getNodeProps: T,
+          getDataSet: R,
+          nodeList: o.nodeList,
+          onMouseDown: s.onMouseDown,
+          ariaProps: {
+            role: "tree",
+            "aria-multiselectable": s.multiple,
+            tabIndex: 0,
+            ...We(s)
+          }
+        }
+      )
+    }
+  );
+}
+const S = Oe(
+  Ve
+);
+S.displayName = "Tree";
+S.SHOW_PARENT = ie;
+S.SHOW_ALL = oe;
+S.SHOW_CHILD = ae;
+S.Node = le;
+export {
+  le as TreeNode,
+  S as default
+};

package/tree/index.js

@@ -0,0 +1,6 @@
+import { default as r } from "./Tree.js";
+import { N as t } from "../chunk/CKyu68pu.js";
+export {
+  t as TreeNode,
+  r as default
+};

package/tree/interface.js

@@ -0,0 +1 @@
+

package/tree/util.js

@@ -0,0 +1,76 @@
+import o from "react";
+const C = (t) => {
+  const n = (r) => o.Children.map(r, (e) => {
+    if (!o.isValidElement(e))
+      return;
+    const d = e.key;
+    return {
+      ...e.props,
+      key: d,
+      children: n(e.props.children)
+    };
+  });
+  return n(t);
+};
+function f(t, n) {
+  const r = /* @__PURE__ */ new Set(), e = (d) => {
+    d.map((s) => {
+      const c = s.key, a = n[c];
+      !a || a.disabled || a.disableCheckbox || a.checkable === !1 || (r.add(c), e(a.children || []));
+    });
+  };
+  return t && e(t.children || []), r;
+}
+const u = (t, n, r, e) => {
+  [...n[t].pathParentKeys].reverse().some((s) => {
+    const c = n[s];
+    if (c && !c.disabled && !c.disableCheckbox && c.checkable !== !1) {
+      let a = 0, l = 0;
+      c.children.some(({ key: i }) => {
+        const h = n[i];
+        if (!h || h.disabled || h.disableCheckbox || h.checkable === !1)
+          return !1;
+        if (a++, r.has(i))
+          l++;
+        else if (e.has(i))
+          return l += 0.5, !0;
+      }), !l || l === a ? e.delete(s) : e.add(s), l && l === a ? r.add(s) : r.delete(s);
+    } else
+      return !0;
+  });
+};
+function K(t, n) {
+  const r = new Set(t || []), e = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
+  return t.forEach((s) => {
+    d.has(s) || f(n[s], n).forEach((a) => {
+      d.add(a);
+    }), n[s] && !n[s].pathParentKeys.some(
+      (c) => r.has(c)
+    ) && u(s, n, r, e);
+  }), {
+    checkedKeys: [.../* @__PURE__ */ new Set([...r, ...d])],
+    indeterminateKeys: [...e]
+  };
+}
+function S(t, n, r, e, d) {
+  if (!e[t])
+    return {
+      checkedKeys: r,
+      indeterminateKeys: d
+    };
+  const s = new Set(r), c = new Set(d), a = f(e[t], e), l = s;
+  return n ? (l.add(t), c.delete(t), a.forEach((i) => {
+    l.add(i);
+  })) : (c.delete(t), l.delete(t), a.forEach((i) => {
+    l.delete(i);
+  })), u(t, e, s, c), {
+    checkedKeys: [...l],
+    indeterminateKeys: [...c]
+  };
+}
+export {
+  S as getAllCheckedKeysByCheck,
+  K as getCheckedKeysByInitKeys,
+  f as getChildNodeKeys,
+  C as getTreeDataFromTreeChildren
+};