@unicom-cloud/ui 0.8.45 → 0.8.47

package/chunk/CQvJK4kb.js

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