@unicom-cloud/ui 0.8.90 → 0.8.92

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

@@ -0,0 +1,500 @@
+import X from "react-is";
+function ye(d) {
+  return d && d.__esModule && Object.prototype.hasOwnProperty.call(d, "default") ? d.default : d;
+}
+var A = { exports: {} };
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var C, z;
+function de() {
+  if (z) return C;
+  z = 1;
+  var d = Object.getOwnPropertySymbols, k = Object.prototype.hasOwnProperty, m = Object.prototype.propertyIsEnumerable;
+  function l(s) {
+    if (s == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(s);
+  }
+  function g() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var s = new String("abc");
+      if (s[5] = "de", Object.getOwnPropertyNames(s)[0] === "5")
+        return !1;
+      for (var O = {}, y = 0; y < 10; y++)
+        O["_" + String.fromCharCode(y)] = y;
+      var E = Object.getOwnPropertyNames(O).map(function(v) {
+        return O[v];
+      });
+      if (E.join("") !== "0123456789")
+        return !1;
+      var w = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(v) {
+        w[v] = v;
+      }), Object.keys(Object.assign({}, w)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return C = g() ? Object.assign : function(s, O) {
+    for (var y, E = l(s), w, v = 1; v < arguments.length; v++) {
+      y = Object(arguments[v]);
+      for (var h in y)
+        k.call(y, h) && (E[h] = y[h]);
+      if (d) {
+        w = d(y);
+        for (var x = 0; x < w.length; x++)
+          m.call(y, w[x]) && (E[w[x]] = y[w[x]]);
+      }
+    }
+    return E;
+  }, C;
+}
+var W, B;
+function J() {
+  if (B) return W;
+  B = 1;
+  var d = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return W = d, W;
+}
+var L, H;
+function Z() {
+  return H || (H = 1, L = Function.call.bind(Object.prototype.hasOwnProperty)), L;
+}
+var q, M;
+function ve() {
+  if (M) return q;
+  M = 1;
+  var d = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var k = /* @__PURE__ */ J(), m = {}, l = /* @__PURE__ */ Z();
+    d = function(s) {
+      var O = "Warning: " + s;
+      typeof console < "u" && console.error(O);
+      try {
+        throw new Error(O);
+      } catch {
+      }
+    };
+  }
+  function g(s, O, y, E, w) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var v in s)
+        if (l(s, v)) {
+          var h;
+          try {
+            if (typeof s[v] != "function") {
+              var x = Error(
+                (E || "React class") + ": " + y + " type `" + v + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof s[v] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw x.name = "Invariant Violation", x;
+            }
+            h = s[v](O, v, E, y, null, k);
+          } catch (D) {
+            h = D;
+          }
+          if (h && !(h instanceof Error) && d(
+            (E || "React class") + ": type specification of " + y + " `" + v + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof h + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), h instanceof Error && !(h.message in m)) {
+            m[h.message] = !0;
+            var P = w ? w() : "";
+            d(
+              "Failed " + y + " type: " + h.message + (P ?? "")
+            );
+          }
+        }
+    }
+  }
+  return g.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (m = {});
+  }, q = g, q;
+}
+var Y, G;
+function be() {
+  if (G) return Y;
+  G = 1;
+  var d = X, k = de(), m = /* @__PURE__ */ J(), l = /* @__PURE__ */ Z(), g = /* @__PURE__ */ ve(), s = function() {
+  };
+  process.env.NODE_ENV !== "production" && (s = function(y) {
+    var E = "Warning: " + y;
+    typeof console < "u" && console.error(E);
+    try {
+      throw new Error(E);
+    } catch {
+    }
+  });
+  function O() {
+    return null;
+  }
+  return Y = function(y, E) {
+    var w = typeof Symbol == "function" && Symbol.iterator, v = "@@iterator";
+    function h(e) {
+      var r = e && (w && e[w] || e[v]);
+      if (typeof r == "function")
+        return r;
+    }
+    var x = "<<anonymous>>", P = {
+      array: I("array"),
+      bigint: I("bigint"),
+      bool: I("boolean"),
+      func: I("function"),
+      number: I("number"),
+      object: I("object"),
+      string: I("string"),
+      symbol: I("symbol"),
+      any: $(),
+      arrayOf: ee,
+      element: re(),
+      elementType: ne(),
+      instanceOf: te,
+      node: ue(),
+      objectOf: ae,
+      oneOf: oe,
+      oneOfType: ie,
+      shape: ce,
+      exact: fe
+    };
+    function D(e, r) {
+      return e === r ? e !== 0 || 1 / e === 1 / r : e !== e && r !== r;
+    }
+    function b(e, r) {
+      this.message = e, this.data = r && typeof r == "object" ? r : {}, this.stack = "";
+    }
+    b.prototype = Error.prototype;
+    function j(e) {
+      if (process.env.NODE_ENV !== "production")
+        var r = {}, i = 0;
+      function o(u, t, a, c, p, f, T) {
+        if (c = c || x, f = f || a, T !== m) {
+          if (E) {
+            var N = new Error(
+              "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+            );
+            throw N.name = "Invariant Violation", N;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var V = c + ":" + a;
+            !r[V] && // Avoid spamming the console because they are often not actionable except for lib authors
+            i < 3 && (s(
+              "You are manually calling a React.PropTypes validation function for the `" + f + "` prop on `" + c + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+            ), r[V] = !0, i++);
+          }
+        }
+        return t[a] == null ? u ? t[a] === null ? new b("The " + p + " `" + f + "` is marked as required " + ("in `" + c + "`, but its value is `null`.")) : new b("The " + p + " `" + f + "` is marked as required in " + ("`" + c + "`, but its value is `undefined`.")) : null : e(t, a, c, p, f);
+      }
+      var n = o.bind(null, !1);
+      return n.isRequired = o.bind(null, !0), n;
+    }
+    function I(e) {
+      function r(i, o, n, u, t, a) {
+        var c = i[o], p = _(c);
+        if (p !== e) {
+          var f = S(c);
+          return new b(
+            "Invalid " + u + " `" + t + "` of type " + ("`" + f + "` supplied to `" + n + "`, expected ") + ("`" + e + "`."),
+            { expectedType: e }
+          );
+        }
+        return null;
+      }
+      return j(r);
+    }
+    function $() {
+      return j(O);
+    }
+    function ee(e) {
+      function r(i, o, n, u, t) {
+        if (typeof e != "function")
+          return new b("Property `" + t + "` of component `" + n + "` has invalid PropType notation inside arrayOf.");
+        var a = i[o];
+        if (!Array.isArray(a)) {
+          var c = _(a);
+          return new b("Invalid " + u + " `" + t + "` of type " + ("`" + c + "` supplied to `" + n + "`, expected an array."));
+        }
+        for (var p = 0; p < a.length; p++) {
+          var f = e(a, p, n, u, t + "[" + p + "]", m);
+          if (f instanceof Error)
+            return f;
+        }
+        return null;
+      }
+      return j(r);
+    }
+    function re() {
+      function e(r, i, o, n, u) {
+        var t = r[i];
+        if (!y(t)) {
+          var a = _(t);
+          return new b("Invalid " + n + " `" + u + "` of type " + ("`" + a + "` supplied to `" + o + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return j(e);
+    }
+    function ne() {
+      function e(r, i, o, n, u) {
+        var t = r[i];
+        if (!d.isValidElementType(t)) {
+          var a = _(t);
+          return new b("Invalid " + n + " `" + u + "` of type " + ("`" + a + "` supplied to `" + o + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return j(e);
+    }
+    function te(e) {
+      function r(i, o, n, u, t) {
+        if (!(i[o] instanceof e)) {
+          var a = e.name || x, c = le(i[o]);
+          return new b("Invalid " + u + " `" + t + "` of type " + ("`" + c + "` supplied to `" + n + "`, expected ") + ("instance of `" + a + "`."));
+        }
+        return null;
+      }
+      return j(r);
+    }
+    function oe(e) {
+      if (!Array.isArray(e))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? s(
+          "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+        ) : s("Invalid argument supplied to oneOf, expected an array.")), O;
+      function r(i, o, n, u, t) {
+        for (var a = i[o], c = 0; c < e.length; c++)
+          if (D(a, e[c]))
+            return null;
+        var p = JSON.stringify(e, function(f, T) {
+          var N = S(T);
+          return N === "symbol" ? String(T) : T;
+        });
+        return new b("Invalid " + u + " `" + t + "` of value `" + String(a) + "` " + ("supplied to `" + n + "`, expected one of " + p + "."));
+      }
+      return j(r);
+    }
+    function ae(e) {
+      function r(i, o, n, u, t) {
+        if (typeof e != "function")
+          return new b("Property `" + t + "` of component `" + n + "` has invalid PropType notation inside objectOf.");
+        var a = i[o], c = _(a);
+        if (c !== "object")
+          return new b("Invalid " + u + " `" + t + "` of type " + ("`" + c + "` supplied to `" + n + "`, expected an object."));
+        for (var p in a)
+          if (l(a, p)) {
+            var f = e(a, p, n, u, t + "." + p, m);
+            if (f instanceof Error)
+              return f;
+          }
+        return null;
+      }
+      return j(r);
+    }
+    function ie(e) {
+      if (!Array.isArray(e))
+        return process.env.NODE_ENV !== "production" && s("Invalid argument supplied to oneOfType, expected an instance of array."), O;
+      for (var r = 0; r < e.length; r++) {
+        var i = e[r];
+        if (typeof i != "function")
+          return s(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + se(i) + " at index " + r + "."
+          ), O;
+      }
+      function o(n, u, t, a, c) {
+        for (var p = [], f = 0; f < e.length; f++) {
+          var T = e[f], N = T(n, u, t, a, c, m);
+          if (N == null)
+            return null;
+          N.data && l(N.data, "expectedType") && p.push(N.data.expectedType);
+        }
+        var V = p.length > 0 ? ", expected one of type [" + p.join(", ") + "]" : "";
+        return new b("Invalid " + a + " `" + c + "` supplied to " + ("`" + t + "`" + V + "."));
+      }
+      return j(o);
+    }
+    function ue() {
+      function e(r, i, o, n, u) {
+        return R(r[i]) ? null : new b("Invalid " + n + " `" + u + "` supplied to " + ("`" + o + "`, expected a ReactNode."));
+      }
+      return j(e);
+    }
+    function U(e, r, i, o, n) {
+      return new b(
+        (e || "React class") + ": " + r + " type `" + i + "." + o + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + n + "`."
+      );
+    }
+    function ce(e) {
+      function r(i, o, n, u, t) {
+        var a = i[o], c = _(a);
+        if (c !== "object")
+          return new b("Invalid " + u + " `" + t + "` of type `" + c + "` " + ("supplied to `" + n + "`, expected `object`."));
+        for (var p in e) {
+          var f = e[p];
+          if (typeof f != "function")
+            return U(n, u, t, p, S(f));
+          var T = f(a, p, n, u, t + "." + p, m);
+          if (T)
+            return T;
+        }
+        return null;
+      }
+      return j(r);
+    }
+    function fe(e) {
+      function r(i, o, n, u, t) {
+        var a = i[o], c = _(a);
+        if (c !== "object")
+          return new b("Invalid " + u + " `" + t + "` of type `" + c + "` " + ("supplied to `" + n + "`, expected `object`."));
+        var p = k({}, i[o], e);
+        for (var f in p) {
+          var T = e[f];
+          if (l(e, f) && typeof T != "function")
+            return U(n, u, t, f, S(T));
+          if (!T)
+            return new b(
+              "Invalid " + u + " `" + t + "` key `" + f + "` supplied to `" + n + "`.\nBad object: " + JSON.stringify(i[o], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(e), null, "  ")
+            );
+          var N = T(a, f, n, u, t + "." + f, m);
+          if (N)
+            return N;
+        }
+        return null;
+      }
+      return j(r);
+    }
+    function R(e) {
+      switch (typeof e) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !e;
+        case "object":
+          if (Array.isArray(e))
+            return e.every(R);
+          if (e === null || y(e))
+            return !0;
+          var r = h(e);
+          if (r) {
+            var i = r.call(e), o;
+            if (r !== e.entries) {
+              for (; !(o = i.next()).done; )
+                if (!R(o.value))
+                  return !1;
+            } else
+              for (; !(o = i.next()).done; ) {
+                var n = o.value;
+                if (n && !R(n[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function pe(e, r) {
+      return e === "symbol" ? !0 : r ? r["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && r instanceof Symbol : !1;
+    }
+    function _(e) {
+      var r = typeof e;
+      return Array.isArray(e) ? "array" : e instanceof RegExp ? "object" : pe(r, e) ? "symbol" : r;
+    }
+    function S(e) {
+      if (typeof e > "u" || e === null)
+        return "" + e;
+      var r = _(e);
+      if (r === "object") {
+        if (e instanceof Date)
+          return "date";
+        if (e instanceof RegExp)
+          return "regexp";
+      }
+      return r;
+    }
+    function se(e) {
+      var r = S(e);
+      switch (r) {
+        case "array":
+        case "object":
+          return "an " + r;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + r;
+        default:
+          return r;
+      }
+    }
+    function le(e) {
+      return !e.constructor || !e.constructor.name ? x : e.constructor.name;
+    }
+    return P.checkPropTypes = g, P.resetWarningCache = g.resetWarningCache, P.PropTypes = P, P;
+  }, Y;
+}
+var F, K;
+function he() {
+  if (K) return F;
+  K = 1;
+  var d = /* @__PURE__ */ J();
+  function k() {
+  }
+  function m() {
+  }
+  return m.resetWarningCache = k, F = function() {
+    function l(O, y, E, w, v, h) {
+      if (h !== d) {
+        var x = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw x.name = "Invariant Violation", x;
+      }
+    }
+    l.isRequired = l;
+    function g() {
+      return l;
+    }
+    var s = {
+      array: l,
+      bigint: l,
+      bool: l,
+      func: l,
+      number: l,
+      object: l,
+      string: l,
+      symbol: l,
+      any: l,
+      arrayOf: g,
+      element: l,
+      elementType: l,
+      instanceOf: g,
+      node: l,
+      objectOf: g,
+      oneOf: g,
+      oneOfType: g,
+      shape: g,
+      exact: g,
+      checkPropTypes: m,
+      resetWarningCache: k
+    };
+    return s.PropTypes = s, s;
+  }, F;
+}
+var Q;
+function me() {
+  if (Q) return A.exports;
+  if (Q = 1, process.env.NODE_ENV !== "production") {
+    var d = X, k = !0;
+    A.exports = /* @__PURE__ */ be()(d.isElement, k);
+  } else
+    A.exports = /* @__PURE__ */ he()();
+  return A.exports;
+}
+var ge = /* @__PURE__ */ me();
+const Ee = /* @__PURE__ */ ye(ge);
+export {
+  Ee as P
+};

package/dist/react-transition-group/src/CSSTransition.js

@@ -0,0 +1,202 @@
+import { jsx as c } from "react/jsx-runtime";
+import E from "../../dom-helpers/addClass.js";
+import { P as a } from "../chunk/F6QOOr2H.js";
+import u from "../../dom-helpers/removeClass.js";
+import x from "react";
+import { f as C, T as h, c as g } from "../chunk/CPfP7aNL.js";
+var f = Object.defineProperty, v = (i, s, e) => s in i ? f(i, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[s] = e, r = (i, s, e) => v(i, typeof s != "symbol" ? s + "" : s, e);
+const N = (i, s) => i && s && s.split(" ").forEach((e) => E(i, e)), p = (i, s) => i && s && s.split(" ").forEach((e) => u(i, e));
+class l extends x.Component {
+  constructor() {
+    super(...arguments), r(this, "appliedClasses", {
+      appear: {},
+      enter: {},
+      exit: {}
+    }), r(this, "onEnter", (s, e) => {
+      const [t, n] = this.resolveArguments(s, e);
+      this.removeClasses(t, "exit"), this.addClass(t, n ? "appear" : "enter", "base"), this.props.onEnter && this.props.onEnter(s, e);
+    }), r(this, "onEntering", (s, e) => {
+      const [t, n] = this.resolveArguments(s, e), o = n ? "appear" : "enter";
+      this.addClass(t, o, "active"), this.props.onEntering && this.props.onEntering(s, e);
+    }), r(this, "onEntered", (s, e) => {
+      const [t, n] = this.resolveArguments(s, e), o = n ? "appear" : "enter";
+      this.removeClasses(t, o), this.addClass(t, o, "done"), this.props.onEntered && this.props.onEntered(s, e);
+    }), r(this, "onExit", (s) => {
+      const [e] = this.resolveArguments(s);
+      this.removeClasses(e, "appear"), this.removeClasses(e, "enter"), this.addClass(e, "exit", "base"), this.props.onExit && this.props.onExit(s);
+    }), r(this, "onExiting", (s) => {
+      const [e] = this.resolveArguments(s);
+      this.addClass(e, "exit", "active"), this.props.onExiting && this.props.onExiting(s);
+    }), r(this, "onExited", (s) => {
+      const [e] = this.resolveArguments(s);
+      this.removeClasses(e, "exit"), this.addClass(e, "exit", "done"), this.props.onExited && this.props.onExited(s);
+    }), r(this, "resolveArguments", (s, e) => this.props.nodeRef ? [this.props.nodeRef.current, s] : [s, e]), r(this, "getClassNames", (s) => {
+      const { classNames: e } = this.props, t = typeof e == "string", n = t && e ? `${e}-` : "";
+      let o = t ? `${n}${s}` : e[s], d = t ? `${o}-active` : e[`${s}Active`], m = t ? `${o}-done` : e[`${s}Done`];
+      return {
+        baseClassName: o,
+        activeClassName: d,
+        doneClassName: m
+      };
+    });
+  }
+  addClass(s, e, t) {
+    let n = this.getClassNames(e)[`${t}ClassName`];
+    const { doneClassName: o } = this.getClassNames("enter");
+    e === "appear" && t === "done" && o && (n += ` ${o}`), t === "active" && s && C(s), n && (this.appliedClasses[e][t] = n, N(s, n));
+  }
+  removeClasses(s, e) {
+    const {
+      base: t,
+      active: n,
+      done: o
+    } = this.appliedClasses[e];
+    this.appliedClasses[e] = {}, t && p(s, t), n && p(s, n), o && p(s, o);
+  }
+  render() {
+    const { classNames: s, ...e } = this.props;
+    return /* @__PURE__ */ c(
+      h,
+      {
+        ...e,
+        onEnter: this.onEnter,
+        onEntered: this.onEntered,
+        onEntering: this.onEntering,
+        onExit: this.onExit,
+        onExiting: this.onExiting,
+        onExited: this.onExited
+      }
+    );
+  }
+}
+r(l, "defaultProps", {
+  classNames: ""
+});
+l.propTypes = {
+  ...h.propTypes,
+  /**
+   * The animation classNames applied to the component as it appears, enters,
+   * exits or has finished the transition. A single name can be provided, which
+   * will be suffixed for each stage, e.g. `classNames="fade"` applies:
+   *
+   * - `fade-appear`, `fade-appear-active`, `fade-appear-done`
+   * - `fade-enter`, `fade-enter-active`, `fade-enter-done`
+   * - `fade-exit`, `fade-exit-active`, `fade-exit-done`
+   *
+   * A few details to note about how these classes are applied:
+   *
+   * 1. They are _joined_ with the ones that are already defined on the child
+   *    component, so if you want to add some base styles, you can use
+   *    `className` without worrying that it will be overridden.
+   *
+   * 2. If the transition component mounts with `in={false}`, no classes are
+   *    applied yet. You might be expecting `*-exit-done`, but if you think
+   *    about it, a component cannot finish exiting if it hasn't entered yet.
+   *
+   * 2. `fade-appear-done` and `fade-enter-done` will _both_ be applied. This
+   *    allows you to define different behavior for when appearing is done and
+   *    when regular entering is done, using selectors like
+   *    `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply
+   *    an epic entrance animation when element first appears in the DOM using
+   *    [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can
+   *    simply use `fade-enter-done` for defining both cases.
+   *
+   * Each individual classNames can also be specified independently like:
+   *
+   * ```js
+   * classNames={{
+   *  appear: 'my-appear',
+   *  appearActive: 'my-active-appear',
+   *  appearDone: 'my-done-appear',
+   *  enter: 'my-enter',
+   *  enterActive: 'my-active-enter',
+   *  enterDone: 'my-done-enter',
+   *  exit: 'my-exit',
+   *  exitActive: 'my-active-exit',
+   *  exitDone: 'my-done-exit',
+   * }}
+   * ```
+   *
+   * If you want to set these classes using CSS Modules:
+   *
+   * ```js
+   * import styles from './styles.css';
+   * ```
+   *
+   * you might want to use camelCase in your CSS file, that way could simply
+   * spread them instead of listing them one by one:
+   *
+   * ```js
+   * classNames={{ ...styles }}
+   * ```
+   *
+   * @type {string | {
+   *  appear?: string,
+   *  appearActive?: string,
+   *  appearDone?: string,
+   *  enter?: string,
+   *  enterActive?: string,
+   *  enterDone?: string,
+   *  exit?: string,
+   *  exitActive?: string,
+   *  exitDone?: string,
+   * }}
+   */
+  classNames: g,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is
+   * applied.
+   *
+   * **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)
+   */
+  onEnter: a.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter-active' or
+   * 'appear-active' class is applied.
+   *
+   * **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: a.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or
+   * 'appear' classes are **removed** and the `done` class is added to the DOM node.
+   *
+   * **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)
+   */
+  onEntered: a.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit' class is
+   * applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExit: a.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExiting: a.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit' classes
+   * are **removed** and the `exit-done` class is added to the DOM node.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExited: a.func
+};
+export {
+  l as default
+};