@unicom-cloud/ui 0.8.67 → 0.8.69

package/tree-select/List.js

@@ -0,0 +1,124 @@
+import { jsxs as j, jsx as x } from "react/jsx-runtime";
+import z from "lodash/isFunction";
+import I from "lodash/isString";
+import { forwardRef as K, useRef as $, useCallback as u, useMemo as y, useImperativeHandle as F } from "react";
+import H from "../tree/Tree.js";
+function O(r, S) {
+  const {
+    value: c,
+    multiple: d,
+    loadMore: k,
+    treeCheckedStrategy: _,
+    treeCheckStrictly: w,
+    treeData: M,
+    treeProps: b,
+    prefixCls: m,
+    treeCheckable: R
+  } = r, C = b && b.renderTitle, h = $(), p = u(
+    (t, { checkedNodes: e, checked: a, node: l }) => {
+      const i = t.map((n) => {
+        const o = e.find((s) => s && s.props._key === n);
+        return o ? {
+          label: o.props.title,
+          value: o.props._key,
+          disabled: o.props.disabled
+        } : c.find((f) => f.value === n) || {
+          label: n,
+          value: n
+        };
+      });
+      r.onChange(i, {
+        checked: a,
+        trigger: l == null ? void 0 : l.props
+      });
+    },
+    [r.onChange, c]
+  ), g = u(
+    (t, { node: e, selected: a }) => {
+      let l = [
+        {
+          value: e.props._key,
+          label: e.props.title
+        }
+      ];
+      if (d) {
+        l = [...c];
+        const i = l.findIndex((n) => n.value === e.props._key);
+        i > -1 ? l.splice(i, 1) : l.push({
+          value: e.props._key,
+          label: e.props.title
+        });
+      }
+      r.onChange(l, { trigger: e == null ? void 0 : e.props, selected: a });
+    },
+    [r.onChange, c, d]
+  ), v = u((t, { node: e, e: a }) => {
+    var s, f;
+    const { checked: l, checkable: i, disabled: n, disableCheckbox: o } = e.props;
+    h.current && !o && !n && i !== !1 && ((f = (s = h.current) == null ? void 0 : s.handleCheck) == null || f.call(s, !l, e.props._key, a));
+  }, []), L = u(
+    (t) => {
+      if (z(k)) {
+        const e = t.props.dataRef;
+        return k(t, e);
+      }
+      return [];
+    },
+    [k]
+  ), N = u(
+    (t) => {
+      if (C)
+        return C(t);
+      const e = r.inputValue, { title: a } = t;
+      if (e && I(a)) {
+        const l = a.toLowerCase().indexOf(e.toLowerCase());
+        if (l === -1)
+          return a;
+        const i = a.substring(0, l + 1), n = a.substring(l + e.length);
+        return /* @__PURE__ */ j("span", { children: [
+          i,
+          /* @__PURE__ */ x("span", { className: `${m}-highlight`, children: a.substring(l, e.length + 1) }),
+          n
+        ] });
+      }
+      return a;
+    },
+    [m, r.inputValue, C]
+  ), V = y(() => r.treeCheckable ? {
+    onCheck: p,
+    checkedKeys: c.map((t) => t.value)
+  } : {}, [p, c, r.treeCheckable]), T = y(() => r.treeCheckable ? [] : c.map((t) => t.value), [r.treeCheckable, c]), D = u(
+    (t, e) => {
+      r.treeCheckable ? v(t, e) : g(t, e);
+    },
+    [r.treeCheckable, v, g]
+  );
+  return F(S, () => h.current, []), /* @__PURE__ */ x(
+    H,
+    {
+      ref: h,
+      size: r.size,
+      blockNode: !0,
+      filterNode: r.filterNode,
+      ...b,
+      checkable: R,
+      multiple: d,
+      loadMore: r.loadMore ? L : void 0,
+      checkedStrategy: _,
+      checkStrictly: w,
+      onMouseDown: (t) => {
+        t.preventDefault();
+      },
+      ...V,
+      treeData: M,
+      fieldNames: r.fieldNames,
+      renderTitle: N,
+      onSelect: D,
+      selectedKeys: T
+    }
+  );
+}
+const G = K(O);
+export {
+  G as default
+};

package/tree-select/Select.js

@@ -0,0 +1,395 @@
+import { jsx as D } from "react/jsx-runtime";
+import { H as be, z as ye, G as Ce } from "../chunk/URXCKjXr.js";
+import ke from "lodash/debounce";
+import B from "lodash/isArray";
+import R from "lodash/isFunction";
+import Se from "lodash/isNil";
+import { useContext as ce, useRef as P, useState as G, useCallback as T, forwardRef as Ve, useEffect as re, useMemo as ve, useImperativeHandle as Pe } from "react";
+import { a as se } from "../chunk/ll867Bf3.js";
+import { u as Ie } from "../chunk/B4YRLi8r.js";
+import { u as Ke } from "../chunk/oopARUrq.js";
+import { u as Oe } from "../chunk/BFTV6myl.js";
+import { u as ne } from "../chunk/CdaT1b_F.js";
+import Te from "../select-view/index.js";
+import V from "../tree/Tree.js";
+import { getCheckedKeysByInitKeys as _e, getTreeDataFromTreeChildren as He, getAllCheckedKeysByCheck as De } from "../tree/util.js";
+import Re from "../trigger/index.js";
+import { m as q } from "../chunk/JPPo5nY_.js";
+import "../chunk/D-TPB2Do.js";
+import we from "./List.js";
+import v from "lodash/get";
+import { u as Le } from "../chunk/CQ_WOOmf.js";
+import { u as J } from "../chunk/BSCrLtfQ.js";
+import { DefaultFieldNames as ue } from "./interface.js";
+import le from "lodash/isEqualWith";
+import Ne from "lodash/isPlainObject";
+import Ee from "lodash/isUndefined";
+import { normalizeValueToArray as W } from "./util.js";
+import { u as Fe } from "../chunk/VSe_Wq1g.js";
+import oe from "lodash/isPlainObject.js";
+const ie = (r, u, o) => {
+  const a = {};
+  let f = 0;
+  const i = (e, c) => {
+    const p = e.length;
+    return e.map((n, y) => {
+      const g = v(n, o.children) || n[o.children], m = v(n, o.key) || n[o.key] || `${(c == null ? void 0 : c._key) || ""}-${y}`, s = {
+        ...n,
+        title: v(n, o.title) || n[o.title],
+        selectable: v(n, o.selectable) || n[o.selectable],
+        disabled: v(n, o.disabled) || n[o.disabled],
+        disableCheckbox: v(n, o.disableCheckbox) || n[o.disableCheckbox],
+        checkable: v(n, o.checkable) || n[o.checkable],
+        isLeaf: v(n, o.isLeaf) || n[o.isLeaf],
+        key: m,
+        children: g,
+        _key: m,
+        parentKey: c ? c._key : void 0,
+        pathParentKeys: c && c.pathParentKeys || [],
+        _level: c._level || 0,
+        _index: f++
+      };
+      return p === y + 1 && (s.className = q(
+        `${u}-node-is-tail`,
+        s.className
+      )), a[m] = s, g && g.length && (a[m].children = i(g, {
+        _key: m,
+        _level: s._level + 1,
+        pathParentKeys: [...(c == null ? void 0 : c.pathParentKeys) || [], m]
+      })), s;
+    });
+  };
+  return i(r || [], {}), a;
+}, We = (r, u) => {
+  const { getPrefixCls: o } = ce(se), a = {
+    ...ue,
+    ...u
+  }, f = Le(), i = o("tree"), e = P(
+    ie(r, i, a)
+  );
+  return J(() => {
+    e.current = ie(r, i, a), f();
+  }, [r]), e.current;
+}, x = (r, u, o) => r == null ? [] : (B(r) ? r : [r]).map((f) => {
+  let i = Ne(f) ? { ...f } : { value: f, label: void 0 };
+  const e = u[i.value];
+  if (e)
+    i.label = i.label || e.title, i.disabled = e.disabled;
+  else if (B(o)) {
+    const c = o.find((p) => p.value === i.value);
+    i = {
+      ...i,
+      ...c
+    };
+  }
+  return Ee(i.label) && (i.label = i.value), i;
+}), xe = (r, u, o, a) => {
+  if (!a.treeCheckStrictly) {
+    const { checkedKeys: f, indeterminateKeys: i } = _e(r, u);
+    let e = f;
+    return o.current = i, a.treeCheckedStrategy === V.SHOW_PARENT ? e = e.filter((c) => {
+      const p = u[c];
+      if (!p || e.indexOf(p.parentKey) === -1)
+        return !0;
+    }) : a.treeCheckedStrategy === V.SHOW_CHILD && (e = e.filter((c) => {
+      const p = u[c];
+      if (!p || !p.children || !p.children.length)
+        return !0;
+    })), e;
+  }
+  return o.current = [], r;
+}, Ae = (r, u, o) => {
+  const a = P([]), f = () => {
+    const n = r.value || r.defaultValue || [];
+    if (r.treeCheckable) {
+      const y = xe(
+        W(n),
+        u,
+        o,
+        r
+      ), g = x(
+        n,
+        u,
+        a.current
+      );
+      return x(
+        y,
+        u,
+        g
+      );
+    }
+    return x(n, u);
+  }, [i, e] = G(f), c = (n) => {
+    a.current = n, e(n);
+  };
+  J(() => {
+    const n = f();
+    "value" in r && (r.labelInValue ? le(
+      W(i),
+      W(n)
+    ) || c(n) : le(i, n) || c(n));
+  }, [
+    r.treeCheckedStrategy,
+    r.treeCheckStrictly,
+    r.treeCheckable,
+    r.value,
+    u
+  ]);
+  const p = T(
+    (n, y) => {
+      const { onChange: g, labelInValue: m } = r, s = r.multiple || r.treeCheckable;
+      "value" in r || c(n);
+      let I;
+      s ? I = n.map((_) => m ? { label: _.label, value: _.value } : _.value) : I = m ? n[0] : n[0] && n[0].value, g == null || g(I, y);
+    },
+    [
+      r.onChange,
+      r.labelInValue,
+      r.multiple,
+      r.treeCheckable,
+      r.value
+    ]
+  );
+  return [i, p];
+};
+function $e(r) {
+  const u = Fe(r) || {}, o = () => r.treeData || He(r.children), [a, f] = G(o());
+  return J(() => {
+    (r.treeData !== u.treeData || r.children !== u.children) && f(o());
+  }, [r]), [a];
+}
+const Me = {
+  bordered: !0,
+  treeCheckedStrategy: V.SHOW_CHILD,
+  fieldNames: ue
+}, Ue = { bottom: 4 }, je = (r, u) => {
+  const { getPrefixCls: o, renderEmpty: a, componentConfig: f, rtl: i } = ce(se), e = Oe(
+    r,
+    Me,
+    f == null ? void 0 : f.TreeSelect
+  ), c = Ke(), p = P(), n = P(null), y = P(null), g = P([]), [m] = $e(e), s = We(m, e.fieldNames), [I, _] = G(), [K, ae] = ne(!1, {
+    value: e.popupVisible
+  }), [b, fe] = ne(
+    void 0,
+    // Compatible with previous behavior 'undefined as default'
+    {
+      value: "inputValue" in e ? e.inputValue || "" : void 0
+    }
+  ), L = P(b), Q = P(null), { onInputValueChange: A } = e, [C, $] = Ae(
+    e,
+    s,
+    g
+  ), H = e.multiple || e.treeCheckable, O = o("tree-select"), M = b && !R(e.onSearch), X = Ie(`${O}-popup-`), Y = (t) => {
+    var l;
+    t !== K && (ae(t), (l = e.onVisibleChange) == null || l.call(e, t));
+  }, U = (t, l) => {
+    (t !== L.current || l !== Q.current) && (fe(t), L.current = t, Q.current = l, A == null || A(t, l));
+  }, de = T(
+    (t) => ke(async (d) => {
+      if (R(e.onSearch)) {
+        await e.onSearch(d);
+        return;
+      }
+      if (!d)
+        return m;
+      const h = /* @__PURE__ */ new Set();
+      Object.keys(s).forEach((k) => {
+        const S = s[k];
+        let E = !1;
+        if (R(e.filterTreeNode))
+          e.filterTreeNode(d, /* @__PURE__ */ D(V.Node, { ...S })) && (E = !0);
+        else {
+          const F = S.value || S._key;
+          F && F.indexOf(d) > -1 && (E = !0);
+        }
+        E && h.add(S.key);
+      }), _(h);
+    }, 100)(t),
+    [e.onSearch, m, s, e.filterTreeNode]
+  ), Z = T(() => {
+    let t = !0;
+    oe(e.showSearch) && (t = e.showSearch.retainInputValueWhileSelect !== !1), e.multiple && !t && b !== void 0 && U("", "optionChecked");
+  }, [b, e.multiple, JSON.stringify(e.showSearch)]), N = T(
+    (t, l) => {
+      $(t, l), Z(), H || Y(!1);
+    },
+    [$, Z, K]
+  ), me = (t, l, d) => {
+    if (d.stopPropagation(), t.disabled)
+      return;
+    const h = oe(t.value) ? t.value.value : t.value;
+    if (!e.treeCheckable || e.treeCheckStrictly || !s[h]) {
+      const S = C.filter((E, F) => F !== l);
+      N(S, {
+        trigger: s[h] || t,
+        checked: !1,
+        selected: !1
+      });
+      return;
+    }
+    const k = De(
+      h,
+      !1,
+      W(C),
+      s,
+      g.current
+    );
+    g.current = k.indeterminateKeys, N(x(k.checkedKeys, s, C), {
+      trigger: s[h],
+      checked: !1,
+      selected: !1
+    });
+  };
+  function j(t) {
+    return be(t) || ye(t) || Ce(t);
+  }
+  re(() => {
+    b !== void 0 && de(b), b !== L.current && (L.current = b);
+  }, [b]);
+  const z = ve(() => {
+    let t = [];
+    if (b)
+      for (const l in s) {
+        const h = [...s[l].pathParentKeys, l];
+        h.some((k) => I && I.has(k)) && (t = t.concat(h));
+      }
+    return Array.from(new Set(t));
+  }, [b, s, I]);
+  re(() => {
+    K ? setTimeout(() => {
+      const t = C[0];
+      n.current && t && n.current.scrollIntoView(t.value);
+    }) : c || b && U("", "optionListHide");
+  }, [K]), Pe(u, () => ({
+    focus() {
+      y.current && y.current.focus();
+    },
+    blur() {
+      y.current && y.current.blur();
+    },
+    getRootDOMNode: () => {
+      var t, l;
+      return (l = (t = y.current) == null ? void 0 : t.getRootDOMNode) == null ? void 0 : l.call(t);
+    }
+  }));
+  const he = T(
+    (t) => M ? z.indexOf(t._key) > -1 : !0,
+    [M, z]
+  ), pe = T(
+    (t) => {
+      const { disabled: l, value: d } = t || {};
+      let h = t == null ? void 0 : t.label;
+      return R(e.renderFormat) && (h = e.renderFormat(
+        s[d] || null,
+        e.labelInValue ? t : d
+      )), { text: h || d || "", disabled: l };
+    },
+    [e.renderFormat, e.labelInValue, s]
+  ), ge = (t) => {
+    $(t, {});
+  }, ee = (t) => /* @__PURE__ */ D(
+    Re,
+    {
+      autoAlignPopupWidth: !1,
+      autoAlignPopupMinWidth: !0,
+      ref: p,
+      classNames: "slideDynamicOrigin",
+      trigger: "click",
+      position: "bl",
+      getPopupContainer: e.getPopupContainer,
+      popupAlign: Ue,
+      unmountOnExit: e.unmountOnExit,
+      ...e.triggerProps,
+      className: q(
+        `${O}-trigger`,
+        e.triggerProps && e.triggerProps.className
+      ),
+      popup: () => {
+        var h, k, S;
+        const l = e.dropdownRender, d = M && j(z) || j(m) ? e.notFoundContent || (a == null ? void 0 : a("TreeSelect")) : /* @__PURE__ */ D(
+          we,
+          {
+            prefixCls: O,
+            ref: n,
+            ...e,
+            inputValue: b,
+            filterNode: he,
+            value: C,
+            onChange: N,
+            multiple: H,
+            treeData: m
+          }
+        );
+        return /* @__PURE__ */ D(
+          "div",
+          {
+            id: X,
+            className: q(`${O}-popup`, {
+              [`${O}-rtl-popup`]: i
+            }),
+            style: {
+              maxHeight: (h = e.treeProps) != null && h.height || (S = (k = e.treeProps) == null ? void 0 : k.virtualListProps) != null && S.height ? "unset" : "",
+              ...e.dropdownMenuStyle
+            },
+            children: R(l) ? l(d) : d
+          }
+        );
+      },
+      disabled: e.disabled,
+      onVisibleChange: (l) => {
+        Y(l);
+      },
+      popupVisible: K,
+      children: t
+    }
+  ), te = typeof e.triggerElement == "function" ? (() => {
+    var l;
+    let t;
+    return H ? t = C.map(
+      (d) => e.labelInValue ? { label: d.label, value: d.value } : d.value
+    ) : t = e.labelInValue ? C[0] : (l = C[0]) == null ? void 0 : l.value, e.triggerElement({ value: t });
+  })() : e.triggerElement;
+  return Se(te) ? /* @__PURE__ */ D(
+    Te,
+    {
+      ref: y,
+      rtl: i,
+      ariaControls: X,
+      ...e,
+      popupVisible: K,
+      value: !H && B(C) ? C[0] : C,
+      inputValue: b,
+      isEmptyValue: j(C),
+      prefixCls: O,
+      isMultiple: H,
+      renderText: pe,
+      onSort: ge,
+      onRemoveCheckedItem: me,
+      onClear: (t) => {
+        var l;
+        t.stopPropagation(), N([], {}), (l = e.onClear) == null || l.call(e, !!K);
+      },
+      onKeyDown: (t) => {
+        var l;
+        t.stopPropagation(), (l = e.onKeyDown) == null || l.call(e, t);
+      },
+      onFocus: (t) => {
+        t && t.stopPropagation();
+      },
+      onChangeInputValue: (t) => {
+        U(t, "manual");
+      },
+      renderView: ee
+    }
+  ) : ee(te);
+}, ze = Ve(je), w = ze;
+w.displayName = "TreeSelect";
+w.Node = V.Node;
+w.SHOW_ALL = V.SHOW_ALL;
+w.SHOW_PARENT = V.SHOW_PARENT;
+w.SHOW_CHILD = V.SHOW_CHILD;
+const St = V.Node;
+export {
+  St as TreeSelectTreeNode,
+  w as default
+};

package/tree-select/index.js

@@ -0,0 +1,6 @@
+import o from "./Select.js";
+import { TreeSelectTreeNode as m } from "./Select.js";
+export {
+  m as TreeSelectTreeNode,
+  o as default
+};

package/tree-select/interface.js

@@ -0,0 +1,13 @@
+const e = {
+  key: "key",
+  title: "title",
+  children: "children",
+  selectable: "selectable",
+  disabled: "disabled",
+  disableCheckbox: "disableCheckbox",
+  checkable: "checkable",
+  isLeaf: "isLeaf"
+};
+export {
+  e as DefaultFieldNames
+};

package/tree-select/util.js

@@ -0,0 +1,9 @@
+import o from "lodash/isArray";
+import t from "lodash/isPlainObject";
+const m = (r) => {
+  let i = r;
+  return o(r) || (i = r == null ? [] : [r]), i.map((e) => t(e) ? e.value : e);
+};
+export {
+  m as normalizeValueToArray
+};