@unicom-cloud/ui 0.8.90 → 0.8.92

package/dist/compute-scroll-into-view/src/index.js

@@ -0,0 +1,126 @@
+const Z = (t) => typeof t == "object" && t != null && t.nodeType === 1, _ = (t, e) => e && t === "hidden" ? !1 : t !== "visible" && t !== "clip", et = (t) => {
+  if (!t.ownerDocument || !t.ownerDocument.defaultView)
+    return null;
+  try {
+    return t.ownerDocument.defaultView.frameElement;
+  } catch {
+    return null;
+  }
+}, ot = (t) => {
+  const e = et(t);
+  return e ? e.clientHeight < t.scrollHeight || e.clientWidth < t.scrollWidth : !1;
+}, D = (t, e) => {
+  if (t.clientHeight < t.scrollHeight || t.clientWidth < t.scrollWidth) {
+    const h = getComputedStyle(t, null);
+    return _(h.overflowY, e) || _(h.overflowX, e) || ot(t);
+  }
+  return !1;
+}, L = (t, e, h, b, S, n, l, f) => n < t && l > e || n > t && l < e ? 0 : n <= t && f <= h || l >= e && f >= h ? n - t - b : l > e && f < h || n < t && f > h ? l - e + S : 0, nt = (t) => t.parentElement ?? (t.getRootNode().host || null), lt = (t) => {
+  const e = window.getComputedStyle(t);
+  return {
+    top: parseFloat(e.scrollMarginTop) || 0,
+    right: parseFloat(e.scrollMarginRight) || 0,
+    bottom: parseFloat(e.scrollMarginBottom) || 0,
+    left: parseFloat(e.scrollMarginLeft) || 0
+  };
+}, rt = (t, e) => {
+  var h, b;
+  if (typeof document > "u")
+    return [];
+  const { scrollMode: S, block: n, inline: l, boundary: f, skipOverflowHiddenElements: $ } = e, tt = typeof f == "function" ? f : (W) => W !== f;
+  if (!Z(t))
+    throw new TypeError("Invalid target");
+  const X = document.scrollingElement || document.documentElement, H = [];
+  let s = t;
+  for (; Z(s) && tt(s); ) {
+    if (s = nt(s), s === X) {
+      H.push(s);
+      break;
+    }
+    s != null && s === document.body && D(s) && !D(document.documentElement) || s != null && D(s, $) && H.push(s);
+  }
+  const a = ((h = window.visualViewport) == null ? void 0 : h.width) ?? innerWidth, u = ((b = window.visualViewport) == null ? void 0 : b.height) ?? innerHeight, { scrollX: g, scrollY: p } = window, {
+    height: m,
+    width: w,
+    top: y,
+    right: Y,
+    bottom: j,
+    left: M
+  } = t.getBoundingClientRect(), {
+    top: G,
+    right: J,
+    bottom: K,
+    left: P
+  } = lt(t);
+  let d = n === "start" || n === "nearest" ? y - G : n === "end" ? j + K : y + m / 2 - G + K, c = l === "center" ? M + w / 2 - P + J : l === "end" ? Y + J : M - P;
+  const N = [];
+  for (let W = 0; W < H.length; W++) {
+    const o = H[W], { height: v, width: E, top: x, right: O, bottom: q, left: C } = o.getBoundingClientRect();
+    if (S === "if-needed" && y >= 0 && M >= 0 && j <= u && Y <= a && // scrollingElement is added to the frames array even if it's not scrollable, in which case checking its bounds is not required
+    (o === X && !D(o) || y >= x && j <= q && M >= C && Y <= O))
+      return N;
+    const I = getComputedStyle(o), R = parseInt(I.borderLeftWidth, 10), T = parseInt(I.borderTopWidth, 10), B = parseInt(I.borderRightWidth, 10), F = parseInt(I.borderBottomWidth, 10);
+    let r = 0, i = 0;
+    const V = "offsetWidth" in o ? o.offsetWidth - o.clientWidth - R - B : 0, k = "offsetHeight" in o ? o.offsetHeight - o.clientHeight - T - F : 0, z = "offsetWidth" in o ? o.offsetWidth === 0 ? 0 : E / o.offsetWidth : 0, A = "offsetHeight" in o ? o.offsetHeight === 0 ? 0 : v / o.offsetHeight : 0;
+    if (X === o)
+      n === "start" ? r = d : n === "end" ? r = d - u : n === "nearest" ? r = L(
+        p,
+        p + u,
+        u,
+        T,
+        F,
+        p + d,
+        p + d + m,
+        m
+      ) : r = d - u / 2, l === "start" ? i = c : l === "center" ? i = c - a / 2 : l === "end" ? i = c - a : i = L(
+        g,
+        g + a,
+        a,
+        R,
+        B,
+        g + c,
+        g + c + w,
+        w
+      ), r = Math.max(0, r + p), i = Math.max(0, i + g);
+    else {
+      n === "start" ? r = d - x - T : n === "end" ? r = d - q + F + k : n === "nearest" ? r = L(
+        x,
+        q,
+        v,
+        T,
+        F + k,
+        d,
+        d + m,
+        m
+      ) : r = d - (x + v / 2) + k / 2, l === "start" ? i = c - C - R : l === "center" ? i = c - (C + E / 2) + V / 2 : l === "end" ? i = c - O + B + V : i = L(
+        C,
+        O,
+        E,
+        R,
+        B + V,
+        c,
+        c + w,
+        w
+      );
+      const { scrollLeft: Q, scrollTop: U } = o;
+      r = A === 0 ? 0 : Math.max(
+        0,
+        Math.min(
+          U + r / A,
+          o.scrollHeight - v / A + k
+        )
+      ), i = z === 0 ? 0 : Math.max(
+        0,
+        Math.min(
+          Q + i / z,
+          o.scrollWidth - E / z + V
+        )
+      ), d += U - r, c += Q - i;
+    }
+    N.push({ el: o, top: r, left: i });
+  }
+  return N;
+};
+export {
+  rt as compute
+};

package/dist/dom-helpers/addClass.js

@@ -0,0 +1,10 @@
+import t from "./hasClass.js";
+function c(a, s) {
+  a.classList ? a.classList.add(s) : t(a, s) || (typeof a.className == "string" ? a.className = `${a.className} ${s}` : a.setAttribute(
+    "class",
+    `${a.className && a.className.baseVal || ""} ${s}`
+  ));
+}
+export {
+  c as default
+};

package/dist/dom-helpers/hasClass.js

@@ -0,0 +1,8 @@
+function e(s, a) {
+  return s.classList ? !!a && s.classList.contains(a) : ` ${s.className.baseVal || s.className} `.indexOf(
+    ` ${a} `
+  ) !== -1;
+}
+export {
+  e as default
+};

package/dist/dom-helpers/removeClass.js

@@ -0,0 +1,18 @@
+function a(e, s) {
+  return e.replace(new RegExp(`(^|\\s)${s}(?:\\s|$)`, "g"), "$1").replace(/\s+/g, " ").replace(/^\s*|\s*$/g, "");
+}
+function c(e, s) {
+  e.classList ? e.classList.remove(s) : typeof e.className == "string" ? e.className = a(
+    e.className,
+    s
+  ) : e.setAttribute(
+    "class",
+    a(
+      e.className && e.className.baseVal || "",
+      s
+    )
+  );
+}
+export {
+  c as default
+};

package/dist/react-transition-group/chunk/CPfP7aNL.js

@@ -0,0 +1,381 @@
+import { jsx as S } from "react/jsx-runtime";
+import { P as n } from "./F6QOOr2H.js";
+import E from "react";
+import f from "react-dom";
+import g from "../src/config.js";
+import O from "../src/TransitionGroupContext.js";
+var N = Object.defineProperty, C = (r, t, e) => t in r ? N(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, T = (r, t, e) => C(r, t + "", e);
+const k = process.env.NODE_ENV !== "production" ? n.oneOfType([
+  n.number,
+  n.shape({
+    enter: n.number,
+    exit: n.number,
+    appear: n.number
+  }).isRequired
+]) : null, $ = process.env.NODE_ENV !== "production" ? n.oneOfType([
+  n.string,
+  n.shape({
+    enter: n.string,
+    exit: n.string,
+    active: n.string
+  }),
+  n.shape({
+    enter: n.string,
+    enterDone: n.string,
+    enterActive: n.string,
+    exit: n.string,
+    exitDone: n.string,
+    exitActive: n.string
+  })
+]) : null, R = (r) => r.scrollTop, h = "unmounted", p = "exited", l = "entering", c = "entered", x = "exiting";
+class u extends E.Component {
+  constructor(t, e) {
+    super(t, e);
+    let s = e, i = s && !s.isMounting ? t.enter : t.appear, o;
+    this.appearStatus = null, t.in ? i ? (o = p, this.appearStatus = l) : o = c : t.unmountOnExit || t.mountOnEnter ? o = h : o = p, this.state = { status: o }, this.nextCallback = null;
+  }
+  static getDerivedStateFromProps({ in: t }, e) {
+    return t && e.status === h ? { status: p } : 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: s } = this.state;
+      this.props.in ? s !== l && s !== c && (e = l) : (s === l || s === c) && (e = x);
+    }
+    this.updateStatus(!1, e);
+  }
+  componentWillUnmount() {
+    this.cancelNextCallback();
+  }
+  getTimeouts() {
+    const { timeout: t } = this.props;
+    let e, s, i;
+    return e = s = i = t, t != null && typeof t != "number" && (e = t.exit, s = t.enter, i = t.appear !== void 0 ? t.appear : s), { exit: e, enter: s, appear: i };
+  }
+  updateStatus(t = !1, e) {
+    if (e !== null)
+      if (this.cancelNextCallback(), e === l) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          const s = this.props.nodeRef ? this.props.nodeRef.current : f.findDOMNode(this);
+          s && R(s);
+        }
+        this.performEnter(t);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === p && this.setState({ status: h });
+  }
+  performEnter(t) {
+    const { enter: e } = this.props, s = this.context ? this.context.isMounting : t, [i, o] = this.props.nodeRef ? [s] : [f.findDOMNode(this), s], a = this.getTimeouts(), m = s ? a.appear : a.enter;
+    if (!t && !e || g.disabled) {
+      this.safeSetState({ status: c }, () => {
+        this.props.onEntered(i);
+      });
+      return;
+    }
+    this.props.onEnter(i, o), this.safeSetState({ status: l }, () => {
+      this.props.onEntering(i, o), this.onTransitionEnd(m, () => {
+        this.safeSetState({ status: c }, () => {
+          this.props.onEntered(i, o);
+        });
+      });
+    });
+  }
+  performExit() {
+    const { exit: t } = this.props, e = this.getTimeouts(), s = this.props.nodeRef ? void 0 : f.findDOMNode(this);
+    if (!t || g.disabled) {
+      this.safeSetState({ status: p }, () => {
+        this.props.onExited(s);
+      });
+      return;
+    }
+    this.props.onExit(s), this.safeSetState({ status: x }, () => {
+      this.props.onExiting(s), this.onTransitionEnd(e.exit, () => {
+        this.safeSetState({ status: p }, () => {
+          this.props.onExited(s);
+        });
+      });
+    });
+  }
+  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 = (s) => {
+      e && (e = !1, this.nextCallback = null, t(s));
+    }, this.nextCallback.cancel = () => {
+      e = !1;
+    }, this.nextCallback;
+  }
+  onTransitionEnd(t, e) {
+    this.setNextCallback(e);
+    const s = this.props.nodeRef ? this.props.nodeRef.current : f.findDOMNode(this), i = t == null && !this.props.addEndListener;
+    if (!s || i) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      const [o, a] = this.props.nodeRef ? [this.nextCallback] : [s, this.nextCallback];
+      this.props.addEndListener(o, a);
+    }
+    t != null && setTimeout(this.nextCallback, t);
+  }
+  render() {
+    const t = this.state.status;
+    if (t === h)
+      return null;
+    const {
+      children: e,
+      // filter props for `Transition`
+      in: s,
+      mountOnEnter: i,
+      unmountOnExit: o,
+      appear: a,
+      enter: m,
+      exit: D,
+      timeout: v,
+      addEndListener: y,
+      onEnter: M,
+      onEntering: L,
+      onEntered: P,
+      onExit: U,
+      onExiting: q,
+      onExited: I,
+      nodeRef: w,
+      ...b
+    } = this.props;
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ S(O.Provider, { value: null, children: typeof e == "function" ? e(t, b) : E.cloneElement(E.Children.only(e), b) })
+    );
+  }
+}
+T(u, "contextType", O);
+u.propTypes = {
+  /**
+   * A React reference to the DOM element that needs to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - This prop is optional, but recommended in order to avoid defaulting to
+   *      [`ReactDOM.findDOMNode`](https://reactjs.org/docs/react-dom.html#finddomnode),
+   *      which is deprecated in `StrictMode`
+   *   - When `nodeRef` prop is used, `node` is not passed to callback functions
+   *      (e.g. `onEnter`) because user already has direct access to the node.
+   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
+   *     `nodeRef` need to be provided to `Transition` with changed `key` prop
+   *     (see
+   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
+   */
+  nodeRef: n.shape({
+    current: typeof Element > "u" ? n.any : (r, t, e, s, i, o) => {
+      const a = r[t];
+      return n.instanceOf(
+        a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element
+      )(r, t, e, s, i, o);
+    }
+  }),
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition nodeRef={nodeRef} in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent ref={nodeRef} className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: n.oneOfType([
+    n.func.isRequired,
+    n.element.isRequired
+  ]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: n.bool,
+  /**
+   * By default the child component is mounted immediately along with
+   * the parent `Transition` component. If you want to "lazy mount" the component on the
+   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
+   * mounted, even on "exited", unless you also specify `unmountOnExit`.
+   */
+  mountOnEnter: n.bool,
+  /**
+   * By default the child component stays mounted after it reaches the `'exited'` state.
+   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
+   */
+  unmountOnExit: n.bool,
+  /**
+   * By default the child component does not perform the enter transition when
+   * it first mounts, regardless of the value of `in`. If you want this
+   * behavior, set both `appear` and `in` to `true`.
+   *
+   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
+   * > only adds an additional enter transition. However, in the
+   * > `<CSSTransition>` component that first enter transition does result in
+   * > additional `.appear-*` classes, that way you can choose to style it
+   * > differently.
+   */
+  appear: n.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: n.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: n.bool,
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: (r, ...t) => {
+    let e = k;
+    return r.addEndListener || (e = e.isRequired), e(r, ...t);
+  },
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed, so `done` is being passed as the first argument.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: n.func,
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed, so `isAppearing` is being passed as the first argument.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: n.func,
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed, so `isAppearing` is being passed as the first argument.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: n.func,
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed, so `isAppearing` is being passed as the first argument.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: n.func,
+  /**
+   * Callback fired before the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExit: n.func,
+  /**
+   * Callback fired after the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExiting: n.func,
+  /**
+   * Callback fired after the "exited" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExited: n.func
+};
+function d() {
+}
+u.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: d,
+  onEntering: d,
+  onEntered: d,
+  onExit: d,
+  onExiting: d,
+  onExited: d
+};
+u.UNMOUNTED = h;
+u.EXITED = p;
+u.ENTERING = l;
+u.ENTERED = c;
+u.EXITING = x;
+export {
+  c as E,
+  u as T,
+  h as U,
+  l as a,
+  x as b,
+  $ as c,
+  p as d,
+  R as f
+};