@unicom-cloud/ui 0.8.43 → 0.8.45

package/tree-select/List.js

@@ -0,0 +1,127 @@
+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";
+/* empty css                  */
+/* empty css                           */
+/* empty css                       */
+import H from "../tree/Tree.js";
+function O(r, S) {
+  const {
+    value: i,
+    multiple: d,
+    loadMore: k,
+    treeCheckedStrategy: _,
+    treeCheckStrictly: w,
+    treeData: M,
+    treeProps: m,
+    prefixCls: b,
+    treeCheckable: R
+  } = r, p = m && m.renderTitle, h = $(), C = u(
+    (t, { checkedNodes: e, checked: a, node: l }) => {
+      const c = 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
+        } : i.find((f) => f.value === n) || {
+          label: n,
+          value: n
+        };
+      });
+      r.onChange(c, {
+        checked: a,
+        trigger: l == null ? void 0 : l.props
+      });
+    },
+    [r.onChange, i]
+  ), g = u(
+    (t, { node: e, selected: a }) => {
+      let l = [
+        {
+          value: e.props._key,
+          label: e.props.title
+        }
+      ];
+      if (d) {
+        l = [...i];
+        const c = l.findIndex((n) => n.value === e.props._key);
+        c > -1 ? l.splice(c, 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, i, d]
+  ), v = u((t, { node: e, e: a }) => {
+    var s, f;
+    const { checked: l, checkable: c, disabled: n, disableCheckbox: o } = e.props;
+    h.current && !o && !n && c !== !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 (p)
+        return p(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 c = a.substring(0, l + 1), n = a.substring(l + e.length);
+        return /* @__PURE__ */ j("span", { children: [
+          c,
+          /* @__PURE__ */ x("span", { className: `${b}-highlight`, children: a.substring(l, e.length + 1) }),
+          n
+        ] });
+      }
+      return a;
+    },
+    [b, r.inputValue, p]
+  ), V = y(() => r.treeCheckable ? {
+    onCheck: C,
+    checkedKeys: i.map((t) => t.value)
+  } : {}, [C, i, r.treeCheckable]), T = y(() => r.treeCheckable ? [] : i.map((t) => t.value), [r.treeCheckable, i]), 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,
+      ...m,
+      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 U = K(O);
+export {
+  U as default
+};

package/tree-select/Select.js

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

package/tree-select/hook/useKeyCache.js

@@ -0,0 +1,56 @@
+import n from "lodash/get";
+import { useContext as C, useRef as P } from "react";
+/* empty css                     */
+import "../../config-provider/ConfigProvider.js";
+import g from "../../hooks/useForceUpdate.js";
+import m from "../../hooks/useUpdateEffect.js";
+import { DefaultFieldNames as K } from "../interface.js";
+import h from "@unicom-cloud/utils/class-name";
+import { ConfigContext as 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 = h(
+        `${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;
+}, w = (l, y) => {
+  const { getPrefixCls: e } = C(v), s = {
+    ...K,
+    ...y
+  }, k = g(), r = e("tree"), p = P(
+    _(l, r, s)
+  );
+  return m(() => {
+    p.current = _(l, r, s), k();
+  }, [l]), p.current;
+};
+export {
+  w as default
+};

package/tree-select/hook/useStateValue.js

@@ -0,0 +1,98 @@
+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 "../../hooks/useUpdateEffect.js";
+/* empty css                     */
+/* empty css                              */
+/* empty css                          */
+import k from "../../tree/Tree.js";
+import { normalizeValueToArray as o } from "../util.js";
+import { getCheckedKeysByInitKeys as E } from "../../tree/util.js";
+const C = (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 u = n.find((r) => r.value === t.value);
+    t = {
+      ...t,
+      ...u
+    };
+  }
+  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((u) => {
+      const r = i[u];
+      if (!r || a.indexOf(r.parentKey) === -1)
+        return !0;
+    }) : f.treeCheckedStrategy === k.SHOW_CHILD && (a = a.filter((u) => {
+      const r = i[u];
+      if (!r || !r.children || !r.children.length)
+        return !0;
+    })), a;
+  }
+  return n.current = [], e;
+}, F = (e, i, n) => {
+  const f = g([]), c = () => {
+    const l = e.value || e.defaultValue || [];
+    if (e.treeCheckable) {
+      const s = H(
+        o(l),
+        i,
+        n,
+        e
+      ), m = C(
+        l,
+        i,
+        f.current
+      );
+      return C(
+        s,
+        i,
+        m
+      );
+    }
+    return C(l, i);
+  }, [t, a] = I(c), u = (l) => {
+    f.current = l, a(l);
+  };
+  A(() => {
+    const l = c();
+    "value" in e && (e.labelInValue ? V(
+      o(t),
+      o(l)
+    ) || u(l) : V(t, l) || u(l));
+  }, [
+    e.treeCheckedStrategy,
+    e.treeCheckStrictly,
+    e.treeCheckable,
+    e.value,
+    i
+  ]);
+  const r = O(
+    (l, s) => {
+      const { onChange: m, labelInValue: d } = e, y = e.multiple || e.treeCheckable;
+      "value" in e || u(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, r];
+};
+export {
+  F as default,
+  C as parseValue
+};

package/tree-select/hook/useTreeData.js

@@ -0,0 +1,13 @@
+import { useState as n } from "react";
+import o from "../../hooks/usePrevious.js";
+import f from "../../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/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
+};

package/trigger/Portal.js

@@ -0,0 +1,14 @@
+import { useRef as i, useEffect as c } from "react";
+import s from "react-dom";
+import u from "../hooks/useIsFirstRender.js";
+import { isServerRendering as a } from "../utils/dom.js";
+const R = (t) => {
+  const { getContainer: n, children: o } = t, r = i();
+  return (u() || r.current === null) && !a && (r.current = n()), c(() => () => {
+    const e = r.current;
+    e && e.parentNode && (e.parentNode.removeChild(e), r.current = null);
+  }, []), r.current ? s.createPortal(o, r.current) : null;
+};
+export {
+  R as default
+};