@unicom-cloud/ui 0.8.90 → 0.8.92

package/tree-select/List.js

@@ -1,8 +1,124 @@
-import "react/jsx-runtime";
-import "lodash/isFunction";
-import "lodash/isString";
-import "react";
-import { a6 as a } from "../chunk/BbQEqpOn.js";
+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 {
-  a as default
+  G as default
 };

package/tree-select/Select.js

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

package/tree-select/hook/useKeyCache.js

@@ -0,0 +1,55 @@
+import n from "lodash/get";
+import { useContext as C, useRef as K } from "react";
+import "../../config-provider/ConfigProvider.js";
+import h from "../../components/common/hooks/useForceUpdate.js";
+import m from "../../components/common/hooks/useUpdateEffect.js";
+import { DefaultFieldNames as P } from "../interface.js";
+import g from "@unicom-cloud/utils/class-name";
+import v from "../../config-provider/context.js";
+const _ = (l, y, e) => {
+  const s = {};
+  let k = 0;
+  const r = (p, c) => {
+    const x = p.length;
+    return p.map((o, u) => {
+      const b = n(o, e.children) || o[e.children], t = n(o, e.key) || o[e.key] || `${(c == null ? void 0 : c._key) || ""}-${u}`, i = {
+        ...o,
+        title: n(o, e.title) || o[e.title],
+        selectable: n(o, e.selectable) || o[e.selectable],
+        disabled: n(o, e.disabled) || o[e.disabled],
+        disableCheckbox: n(o, e.disableCheckbox) || o[e.disableCheckbox],
+        checkable: n(o, e.checkable) || o[e.checkable],
+        isLeaf: n(o, e.isLeaf) || o[e.isLeaf],
+        key: t,
+        children: b,
+        _key: t,
+        parentKey: c ? c._key : void 0,
+        pathParentKeys: c && c.pathParentKeys || [],
+        _level: c._level || 0,
+        _index: k++
+      };
+      return x === u + 1 && (i.className = g(
+        `${y}-node-is-tail`,
+        i.className
+      )), s[t] = i, b && b.length && (s[t].children = r(b, {
+        _key: t,
+        _level: i._level + 1,
+        pathParentKeys: [...(c == null ? void 0 : c.pathParentKeys) || [], t]
+      })), i;
+    });
+  };
+  return r(l || [], {}), s;
+}, q = (l, y) => {
+  const { getPrefixCls: e } = C(v), s = {
+    ...P,
+    ...y
+  }, k = h(), r = e == null ? void 0 : e("tree"), p = K(
+    _(l, r, s)
+  );
+  return m(() => {
+    p.current = _(l, r, s), k();
+  }, [l]), p.current;
+};
+export {
+  q as default
+};

package/tree-select/hook/useStateValue.js

@@ -0,0 +1,95 @@
+import v from "lodash/isArray";
+import V from "lodash/isEqualWith";
+import S from "lodash/isPlainObject";
+import K from "lodash/isUndefined";
+import { useRef as g, useState as I, useCallback as O } from "react";
+import A from "../../components/common/hooks/useUpdateEffect.js";
+import k from "../../tree/Tree.js";
+import { normalizeValueToArray as C } from "../util.js";
+import { getCheckedKeysByInitKeys as E } from "../../tree/util.js";
+const o = (e, i, n) => e == null ? [] : (v(e) ? e : [e]).map((c) => {
+  let t = S(c) ? { ...c } : { value: c, label: void 0 };
+  const a = i[t.value];
+  if (a)
+    t.label = t.label || a.title, t.disabled = a.disabled;
+  else if (v(n)) {
+    const r = n.find((u) => u.value === t.value);
+    t = {
+      ...t,
+      ...r
+    };
+  }
+  return K(t.label) && (t.label = t.value), t;
+}), H = (e, i, n, f) => {
+  if (!f.treeCheckStrictly) {
+    const { checkedKeys: c, indeterminateKeys: t } = E(e, i);
+    let a = c;
+    return n.current = t, f.treeCheckedStrategy === k.SHOW_PARENT ? a = a.filter((r) => {
+      const u = i[r];
+      if (!u || a.indexOf(u.parentKey) === -1)
+        return !0;
+    }) : f.treeCheckedStrategy === k.SHOW_CHILD && (a = a.filter((r) => {
+      const u = i[r];
+      if (!u || !u.children || !u.children.length)
+        return !0;
+    })), a;
+  }
+  return n.current = [], e;
+}, D = (e, i, n) => {
+  const f = g([]), c = () => {
+    const l = e.value || e.defaultValue || [];
+    if (e.treeCheckable) {
+      const s = H(
+        C(l),
+        i,
+        n,
+        e
+      ), m = o(
+        l,
+        i,
+        f.current
+      );
+      return o(
+        s,
+        i,
+        m
+      );
+    }
+    return o(l, i);
+  }, [t, a] = I(c), r = (l) => {
+    f.current = l, a(l);
+  };
+  A(() => {
+    const l = c();
+    "value" in e && (e.labelInValue ? V(
+      C(t),
+      C(l)
+    ) || r(l) : V(t, l) || r(l));
+  }, [
+    e.treeCheckedStrategy,
+    e.treeCheckStrictly,
+    e.treeCheckable,
+    e.value,
+    i
+  ]);
+  const u = O(
+    (l, s) => {
+      const { onChange: m, labelInValue: d } = e, y = e.multiple || e.treeCheckable;
+      "value" in e || r(l);
+      let h;
+      y ? h = l.map((b) => d ? { label: b.label, value: b.value } : b.value) : h = d ? l[0] : l[0] && l[0].value, m == null || m(h, s);
+    },
+    [
+      e.onChange,
+      e.labelInValue,
+      e.multiple,
+      e.treeCheckable,
+      e.value
+    ]
+  );
+  return [t, u];
+};
+export {
+  D as default,
+  o as parseValue
+};

package/tree-select/hook/useTreeData.js

@@ -0,0 +1,13 @@
+import { useState as n } from "react";
+import o from "../../components/common/hooks/usePrevious.js";
+import f from "../../components/common/hooks/useUpdateEffect.js";
+import { getTreeDataFromTreeChildren as m } from "../../tree/util.js";
+function s(e) {
+  const t = o(e) || {}, r = () => e.treeData || m(e.children), [a, i] = n(r());
+  return f(() => {
+    (e.treeData !== t.treeData || e.children !== t.children) && i(r());
+  }, [e]), [a];
+}
+export {
+  s as default
+};

package/tree-select/index.js

@@ -1,6 +1,6 @@
-import { x as o } from "../chunk/BbQEqpOn.js";
-import { y as a } from "../chunk/BbQEqpOn.js";
+import o from "./Select.js";
+import { TreeSelectTreeNode as m } from "./Select.js";
 export {
-  a as TreeSelectTreeNode,
+  m as TreeSelectTreeNode,
   o as default
 };

package/trigger/getPopupStyle.js

@@ -1,5 +1,5 @@
-import { isServerRendering as C } from "../utils/dom.js";
-import "../chunk/ClM74To2.js";
+import { isServerRendering as C } from "../components/common/utils/dom.js";
+import "../components/common/utils/is.js";
 import { isArray as X } from "@unicom-cloud/utils/is";
 const A = 0, v = (n, o) => {
   const { position: i } = o, { width: c, height: p, left: g, right: m, top: M, bottom: N } = n.getBoundingClientRect(), t = o.boundaryDistance || {}, k = "left" in t && t.left || A, r = "top" in t && t.top || A;