@unicom-cloud/ui 0.8.45 → 0.8.47

package/chunk/uUGMUxt_.js

@@ -0,0 +1,474 @@
+import { jsx as x } from "react/jsx-runtime";
+import l, { Children as U, isValidElement as C, cloneElement as S, useRef as P, useMemo as V } from "react";
+import R from "react-dom";
+import { supportRef as F } from "../utils/is.js";
+import { findDOMNode as I, callbackOriginRef as w } from "../utils/reactDOM.js";
+const j = {
+  disabled: !1
+}, N = l.createContext(null);
+var G = Object.defineProperty, W = (s, t, e) => t in s ? G(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e, X = (s, t, e) => (W(s, t + "", e), e);
+const A = (s) => s.scrollTop || s.scrollLeft, b = "unmounted", E = "exited", c = "entering", u = "entered", k = "exiting";
+class h extends l.Component {
+  constructor(t, e) {
+    super(t, e);
+    let n = e, i = n && !n.isMounting ? t.enter : t.appear, r;
+    this.appearStatus = null, t.in ? i ? (r = E, this.appearStatus = c) : r = u : t.unmountOnExit || t.mountOnEnter ? r = b : r = E, this.state = { status: r }, this.nextCallback = null;
+  }
+  static getDerivedStateFromProps({ in: t }, e) {
+    return t && e.status === b ? { status: E } : null;
+  }
+  // getSnapshotBeforeUpdate(prevProps) {
+  //   let nextStatus = null
+  //   if (prevProps !== this.props) {
+  //     const { status } = this.state
+  //     if (this.props.in) {
+  //       if (status !== ENTERING && status !== ENTERED) {
+  //         nextStatus = ENTERING
+  //       }
+  //     } else {
+  //       if (status === ENTERING || status === ENTERED) {
+  //         nextStatus = EXITING
+  //       }
+  //     }
+  //   }
+  //   return { nextStatus }
+  // }
+  componentDidMount() {
+    this.updateStatus(!0, this.appearStatus);
+  }
+  componentDidUpdate(t) {
+    let e = null;
+    if (t !== this.props) {
+      const { status: n } = this.state;
+      this.props.in ? n !== c && n !== u && (e = c) : (n === c || n === u) && (e = k);
+    }
+    this.updateStatus(!1, e);
+  }
+  componentWillUnmount() {
+    this.cancelNextCallback();
+  }
+  getTimeouts() {
+    const { timeout: t } = this.props;
+    let e, n, i;
+    return e = n = i = t, t != null && typeof t != "number" && (e = t.exit, n = t.enter, i = t.appear !== void 0 ? t.appear : n), { exit: e, enter: n, appear: i };
+  }
+  updateStatus(t = !1, e) {
+    if (e !== null)
+      if (this.cancelNextCallback(), e === c) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          const n = this.props.nodeRef ? this.props.nodeRef.current : R.findDOMNode(this);
+          n && A(n);
+        }
+        this.performEnter(t);
+      } else
+        this.performExit();
+    else
+      this.props.unmountOnExit && this.state.status === E && this.setState({ status: b });
+  }
+  performEnter(t) {
+    const { enter: e } = this.props, n = this.context ? this.context.isMounting : t, [i, r] = this.props.nodeRef ? [n] : [R.findDOMNode(this), n], o = this.getTimeouts(), a = n ? o.appear : o.enter;
+    if (!t && !e || j.disabled) {
+      this.safeSetState({ status: u }, () => {
+        this.props.onEntered(i);
+      });
+      return;
+    }
+    this.props.onEnter(i, r), this.safeSetState({ status: c }, () => {
+      this.props.onEntering(i, r), this.onTransitionEnd(a, () => {
+        this.safeSetState({ status: u }, () => {
+          this.props.onEntered(i, r);
+        });
+      });
+    });
+  }
+  performExit() {
+    const { exit: t } = this.props, e = this.getTimeouts(), n = this.props.nodeRef ? void 0 : R.findDOMNode(this);
+    if (!t || j.disabled) {
+      this.safeSetState({ status: E }, () => {
+        this.props.onExited(n);
+      });
+      return;
+    }
+    this.props.onExit(n), this.safeSetState({ status: k }, () => {
+      this.props.onExiting(n), this.onTransitionEnd(e.exit, () => {
+        this.safeSetState({ status: E }, () => {
+          this.props.onExited(n);
+        });
+      });
+    });
+  }
+  cancelNextCallback() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }
+  safeSetState(t, e) {
+    e = this.setNextCallback(e), this.setState(t, e);
+  }
+  setNextCallback(t) {
+    let e = !0;
+    return this.nextCallback = (n) => {
+      e && (e = !1, this.nextCallback = null, t(n));
+    }, this.nextCallback.cancel = () => {
+      e = !1;
+    }, this.nextCallback;
+  }
+  onTransitionEnd(t, e) {
+    this.setNextCallback(e);
+    const n = this.props.nodeRef ? this.props.nodeRef.current : R.findDOMNode(this), i = t == null && !this.props.addEndListener;
+    if (!n || i) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      const [r, o] = this.props.nodeRef ? [this.nextCallback] : [n, this.nextCallback];
+      this.props.addEndListener(r, o);
+    }
+    t != null && setTimeout(this.nextCallback, t);
+  }
+  render() {
+    const t = this.state.status;
+    if (t === b)
+      return null;
+    const {
+      children: e,
+      // filter props for `Transition`
+      in: n,
+      mountOnEnter: i,
+      unmountOnExit: r,
+      appear: o,
+      enter: a,
+      exit: p,
+      timeout: g,
+      addEndListener: $,
+      onEnter: rt,
+      onEntering: ot,
+      onEntered: at,
+      onExit: lt,
+      onExiting: ct,
+      onExited: dt,
+      nodeRef: ut,
+      ...T
+    } = this.props;
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ x(N.Provider, { value: null, children: typeof e == "function" ? e(t, T) : l.cloneElement(l.Children.only(e), T) })
+    );
+  }
+}
+X(h, "contextType", N);
+function f() {
+}
+h.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: f,
+  onEntering: f,
+  onEntered: f,
+  onExit: f,
+  onExiting: f,
+  onExited: f
+};
+h.UNMOUNTED = b;
+h.EXITED = E;
+h.ENTERING = c;
+h.ENTERED = u;
+h.EXITING = k;
+var _ = Object.defineProperty, q = (s, t, e) => t in s ? _(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e, d = (s, t, e) => (q(s, typeof t != "symbol" ? t + "" : t, e), e);
+const K = (s, t) => s && t && t.split(" ").forEach((e) => {
+  var n, i;
+  return (i = (n = s == null ? void 0 : s.classList) == null ? void 0 : n.add) == null ? void 0 : i.call(n, e);
+}), y = (s, t) => s && t && t.split(" ").forEach((e) => {
+  var n, i;
+  return (i = (n = s == null ? void 0 : s.classList) == null ? void 0 : n.remove) == null ? void 0 : i.call(n, e);
+});
+let L = class extends l.Component {
+  constructor() {
+    super(...arguments), d(this, "appliedClasses", {
+      appear: {},
+      enter: {},
+      exit: {}
+    }), d(this, "onEnter", (t, e) => {
+      const [n, i] = this.resolveArguments(t, e);
+      this.removeClasses(n, "exit"), this.addClass(n, i ? "appear" : "enter", "base"), this.props.onEnter && this.props.onEnter(t, e);
+    }), d(this, "onEntering", (t, e) => {
+      const [n, i] = this.resolveArguments(t, e), r = i ? "appear" : "enter";
+      this.addClass(n, r, "active"), this.props.onEntering && this.props.onEntering(t, e);
+    }), d(this, "onEntered", (t, e) => {
+      const [n, i] = this.resolveArguments(t, e), r = i ? "appear" : "enter";
+      this.removeClasses(n, r), this.addClass(n, r, "done"), this.props.onEntered && this.props.onEntered(t, e);
+    }), d(this, "onExit", (t) => {
+      const [e] = this.resolveArguments(t);
+      this.removeClasses(e, "appear"), this.removeClasses(e, "enter"), this.addClass(e, "exit", "base"), this.props.onExit && this.props.onExit(t);
+    }), d(this, "onExiting", (t) => {
+      const [e] = this.resolveArguments(t);
+      this.addClass(e, "exit", "active"), this.props.onExiting && this.props.onExiting(t);
+    }), d(this, "onExited", (t) => {
+      const [e] = this.resolveArguments(t);
+      this.removeClasses(e, "exit"), this.addClass(e, "exit", "done"), this.props.onExited && this.props.onExited(t);
+    }), d(this, "resolveArguments", (t, e) => this.props.nodeRef ? [this.props.nodeRef.current, t] : [t, e]), d(this, "getClassNames", (t) => {
+      const { classNames: e } = this.props, n = typeof e == "string", i = n && e ? `${e}-` : "";
+      let r = n ? `${i}${t}` : e[t], o = n ? `${r}-active` : e[`${t}Active`], a = n ? `${r}-done` : e[`${t}Done`];
+      return {
+        baseClassName: r,
+        activeClassName: o,
+        doneClassName: a
+      };
+    });
+  }
+  addClass(t, e, n) {
+    let i = this.getClassNames(e)[`${n}ClassName`];
+    const { doneClassName: r } = this.getClassNames("enter");
+    e === "appear" && n === "done" && r && (i += ` ${r}`), n === "active" && t && A(t), i && (this.appliedClasses[e][n] = i, K(t, i));
+  }
+  removeClasses(t, e) {
+    const {
+      base: n,
+      active: i,
+      done: r
+    } = this.appliedClasses[e];
+    this.appliedClasses[e] = {}, n && y(t, n), i && y(t, i), r && y(t, r);
+  }
+  render() {
+    const { classNames: t, ...e } = this.props;
+    return /* @__PURE__ */ x(
+      h,
+      {
+        ...e,
+        onEnter: this.onEnter,
+        onEntered: this.onEntered,
+        onEntering: this.onEntering,
+        onExit: this.onExit,
+        onExiting: this.onExiting,
+        onExited: this.onExited
+      }
+    );
+  }
+};
+d(L, "defaultProps", {
+  classNames: ""
+});
+var z = Object.defineProperty, B = (s, t, e) => t in s ? z(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e, D = (s, t, e) => (B(s, typeof t != "symbol" ? t + "" : t, e), e);
+function H(s, t) {
+  return !(s === t || l.isValidElement(s) && l.isValidElement(t) && s.key != null && s.key === t.key);
+}
+const v = {
+  out: "out-in",
+  in: "in-out"
+}, O = (s, t, e) => (...n) => {
+  var i, r;
+  (r = (i = s.props)[t]) == null || r.call(i, ...n), e();
+}, J = {
+  [v.out]: ({ current: s, changeState: t }) => l.cloneElement(s, {
+    in: !1,
+    onExited: O(s, "onExited", () => {
+      t(c, null);
+    })
+  }),
+  [v.in]: ({ current: s, changeState: t, children: e }) => [
+    s,
+    l.cloneElement(e, {
+      in: !0,
+      onEntered: O(e, "onEntered", () => {
+        t(c);
+      })
+    })
+  ]
+}, Q = {
+  [v.out]: ({ children: s, changeState: t }) => l.cloneElement(s, {
+    in: !0,
+    onEntered: O(s, "onEntered", () => {
+      t(u, l.cloneElement(s, { in: !0 }));
+    })
+  }),
+  [v.in]: ({ current: s, children: t, changeState: e }) => [
+    l.cloneElement(s, {
+      in: !1,
+      onExited: O(s, "onExited", () => {
+        e(u, l.cloneElement(t, { in: !0 }));
+      })
+    }),
+    l.cloneElement(t, {
+      in: !0
+    })
+  ]
+};
+class Y extends l.Component {
+  constructor() {
+    super(...arguments), D(this, "state", {
+      status: u,
+      current: null
+    }), D(this, "appeared", !1), D(this, "changeState", (t, e = this.state.current) => {
+      this.setState({
+        status: t,
+        current: e
+      });
+    });
+  }
+  componentDidMount() {
+    this.appeared = !0;
+  }
+  static getDerivedStateFromProps(t, e) {
+    return t.children == null ? {
+      current: null
+    } : e.status === c && t.mode === v.in ? {
+      status: c
+    } : e.current && H(e.current, t.children) ? {
+      status: k
+    } : {
+      current: l.cloneElement(t.children, {
+        in: !0
+      })
+    };
+  }
+  render() {
+    const {
+      props: { children: t, mode: e },
+      state: { status: n, current: i }
+    } = this, r = { children: t, current: i, changeState: this.changeState, status: n };
+    let o;
+    switch (n) {
+      case c:
+        o = Q[e](r);
+        break;
+      case k:
+        o = J[e](r);
+        break;
+      case u:
+        o = i;
+    }
+    return /* @__PURE__ */ x(N.Provider, { value: { isMounting: !this.appeared }, children: o });
+  }
+}
+Y.defaultProps = {
+  mode: v.out
+};
+function M(s, t) {
+  let e = (i) => t && C(i) ? t(i) : i, n = /* @__PURE__ */ Object.create(null);
+  return s && U.map(s, (i) => i).forEach((i) => {
+    n[i.key] = e(i);
+  }), n;
+}
+function Z(s, t) {
+  s = s || {}, t = t || {};
+  function e(a) {
+    return a in t ? t[a] : s[a];
+  }
+  let n = /* @__PURE__ */ Object.create(null), i = [];
+  for (let a in s)
+    a in t ? i.length && (n[a] = i, i = []) : i.push(a);
+  let r, o = {};
+  for (let a in t) {
+    if (n[a])
+      for (r = 0; r < n[a].length; r++) {
+        let p = n[a][r];
+        o[n[a][r]] = e(p);
+      }
+    o[a] = e(a);
+  }
+  for (r = 0; r < i.length; r++)
+    o[i[r]] = e(i[r]);
+  return o;
+}
+function m(s, t, e) {
+  return e[t] != null ? e[t] : s.props[t];
+}
+function tt(s, t) {
+  return M(s.children, (e) => S(e, {
+    onExited: t.bind(null, e),
+    in: !0,
+    appear: m(e, "appear", s),
+    enter: m(e, "enter", s),
+    exit: m(e, "exit", s)
+  }));
+}
+function et(s, t, e) {
+  let n = M(s.children), i = Z(t, n);
+  return Object.keys(i).forEach((r) => {
+    let o = i[r];
+    if (!C(o))
+      return;
+    const a = r in t, p = r in n, g = t[r], $ = C(g) && !g.props.in;
+    p && (!a || $) ? i[r] = S(o, {
+      onExited: e.bind(null, o),
+      in: !0,
+      exit: m(o, "exit", s),
+      enter: m(o, "enter", s)
+    }) : !p && a && !$ ? i[r] = S(o, { in: !1 }) : p && a && C(g) && (i[r] = S(o, {
+      onExited: e.bind(null, o),
+      in: g.props.in,
+      exit: m(o, "exit", s),
+      enter: m(o, "enter", s)
+    }));
+  }), i;
+}
+const nt = Object.values || ((s) => Object.keys(s).map((t) => s[t])), st = {
+  component: "div",
+  childFactory: (s) => s
+};
+class it extends l.Component {
+  constructor(t, e) {
+    super(t, e);
+    const n = this.handleExited.bind(this);
+    this.state = {
+      contextValue: { isMounting: !0 },
+      handleExited: n,
+      firstRender: !0
+    };
+  }
+  componentDidMount() {
+    this.mounted = !0, this.setState({
+      contextValue: { isMounting: !1 }
+    });
+  }
+  componentWillUnmount() {
+    this.mounted = !1;
+  }
+  static getDerivedStateFromProps(t, { children: e, handleExited: n, firstRender: i }) {
+    return {
+      children: i ? tt(t, n) : et(t, e, n),
+      firstRender: !1
+    };
+  }
+  // node is `undefined` when user provided `nodeRef` prop
+  handleExited(t, e) {
+    let n = M(this.props.children);
+    t.key in n || (t.props.onExited && t.props.onExited(e), this.mounted && this.setState((i) => {
+      let r = { ...i.children };
+      return delete r[t.key], { children: r };
+    }));
+  }
+  render() {
+    const { component: t, childFactory: e, ...n } = this.props, { contextValue: i } = this.state, r = nt(this.state.children).map(e);
+    return delete n.appear, delete n.enter, delete n.exit, t === null ? /* @__PURE__ */ x(N.Provider, { value: i, children: r }) : /* @__PURE__ */ x(N.Provider, { value: i, children: /* @__PURE__ */ x(t, { ...n, children: r }) });
+  }
+}
+it.defaultProps = st;
+function vt(s) {
+  const { children: t, ...e } = s, n = P(), i = P(), r = V(() => s.nodeRef === void 0 && F(t) && C(t) ? (i.current = !0, S(t, {
+    ref: (o) => {
+      n.current = I(o), w(t, o);
+    }
+  })) : (i.current = !1, t), [t, s.nodeRef]);
+  return i.current && [
+    "onEnter",
+    "onEntering",
+    "onEntered",
+    "onExit",
+    "onExiting",
+    "onExited"
+  ].forEach((o) => {
+    s[o] && (e[o] = (a, ...p) => {
+      s[o](n.current, ...p);
+    });
+  }), /* @__PURE__ */ x(L, { ...e, nodeRef: i.current ? n : void 0, children: r });
+}
+export {
+  vt as P,
+  Y as T,
+  it as j,
+  h as l,
+  L as v
+};