@amateescu/portal-ui-components 0.0.38 → 0.0.40

package/dist/useFormControl-DUby-fW8.js

@@ -0,0 +1,498 @@
+import * as b from "react";
+import v from "react";
+import { r as M, n as O, T as D, c as y, P as a } from "./DefaultPropsProvider-8An9vBcT.js";
+import { u as R } from "./useTheme-BHcsKB53.js";
+import { b as I, _ as k, T as S, u as L } from "./ButtonBase-Cj889DO9.js";
+import N from "react-dom";
+import { r as F, m as w, c as P } from "./useSlot-Bvdicoh5.js";
+function U(s) {
+  const {
+    theme: i,
+    name: u,
+    props: n
+  } = s;
+  return !i || !i.components || !i.components[u] || !i.components[u].defaultProps ? n : M(i.components[u].defaultProps, n);
+}
+function G({
+  props: s,
+  name: i,
+  defaultTheme: u,
+  themeId: n
+}) {
+  let e = R(u);
+  return e = e[n] || e, U({
+    theme: e,
+    name: i,
+    props: s
+  });
+}
+function J() {
+  const s = R(O);
+  return process.env.NODE_ENV !== "production" && b.useDebugValue(s), s[D] || s;
+}
+function K({
+  props: s,
+  name: i
+}) {
+  return G({
+    props: s,
+    name: i,
+    defaultTheme: O,
+    themeId: D
+  });
+}
+function Q(s, i, u, n, e) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const t = e || i;
+  return typeof s[i] < "u" ? new Error(`The prop \`${t}\` is not supported. Please remove it.`) : null;
+}
+function V(s, i) {
+  const u = s.charCodeAt(2);
+  return s[0] === "o" && s[1] === "n" && u >= 65 && u <= 90 && typeof i == "function";
+}
+function Y(s, i) {
+  if (!s)
+    return i;
+  function u(r, o) {
+    const p = {};
+    return Object.keys(o).forEach((c) => {
+      V(c, o[c]) && typeof r[c] == "function" && (p[c] = (...f) => {
+        r[c](...f), o[c](...f);
+      });
+    }), p;
+  }
+  if (typeof s == "function" || typeof i == "function")
+    return (r) => {
+      const o = typeof i == "function" ? i(r) : i, p = typeof s == "function" ? s({
+        ...r,
+        ...o
+      }) : s, c = y(r?.className, o?.className, p?.className), f = u(p, o);
+      return {
+        ...o,
+        ...p,
+        ...f,
+        ...!!c && {
+          className: c
+        },
+        ...o?.style && p?.style && {
+          style: {
+            ...o.style,
+            ...p.style
+          }
+        },
+        ...o?.sx && p?.sx && {
+          sx: [...Array.isArray(o.sx) ? o.sx : [o.sx], ...Array.isArray(p.sx) ? p.sx : [p.sx]]
+        }
+      };
+    };
+  const n = i, e = u(s, n), t = y(n?.className, s?.className);
+  return {
+    ...i,
+    ...s,
+    ...e,
+    ...!!t && {
+      className: t
+    },
+    ...n?.style && s?.style && {
+      style: {
+        ...n.style,
+        ...s.style
+      }
+    },
+    ...n?.sx && s?.sx && {
+      sx: [...Array.isArray(n.sx) ? n.sx : [n.sx], ...Array.isArray(s.sx) ? s.sx : [s.sx]]
+    }
+  };
+}
+const C = {
+  disabled: !1
+};
+var q = process.env.NODE_ENV !== "production" ? a.oneOfType([a.number, a.shape({
+  enter: a.number,
+  exit: a.number,
+  appear: a.number
+}).isRequired]) : null, Z = process.env.NODE_ENV !== "production" ? a.oneOfType([a.string, a.shape({
+  enter: a.string,
+  exit: a.string,
+  active: a.string
+}), a.shape({
+  enter: a.string,
+  enterDone: a.string,
+  enterActive: a.string,
+  exit: a.string,
+  exitDone: a.string,
+  exitActive: a.string
+})]) : null, H = function(i) {
+  return i.scrollTop;
+}, x = "unmounted", d = "exited", m = "entering", E = "entered", T = "exiting", l = /* @__PURE__ */ (function(s) {
+  I(i, s);
+  function i(n, e) {
+    var t;
+    t = s.call(this, n, e) || this;
+    var r = e, o = r && !r.isMounting ? n.enter : n.appear, p;
+    return t.appearStatus = null, n.in ? o ? (p = d, t.appearStatus = m) : p = E : n.unmountOnExit || n.mountOnEnter ? p = x : p = d, t.state = {
+      status: p
+    }, t.nextCallback = null, t;
+  }
+  i.getDerivedStateFromProps = function(e, t) {
+    var r = e.in;
+    return r && t.status === x ? {
+      status: d
+    } : null;
+  };
+  var u = i.prototype;
+  return u.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, u.componentDidUpdate = function(e) {
+    var t = null;
+    if (e !== this.props) {
+      var r = this.state.status;
+      this.props.in ? r !== m && r !== E && (t = m) : (r === m || r === E) && (t = T);
+    }
+    this.updateStatus(!1, t);
+  }, u.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, u.getTimeouts = function() {
+    var e = this.props.timeout, t, r, o;
+    return t = r = o = e, e != null && typeof e != "number" && (t = e.exit, r = e.enter, o = e.appear !== void 0 ? e.appear : r), {
+      exit: t,
+      enter: r,
+      appear: o
+    };
+  }, u.updateStatus = function(e, t) {
+    if (e === void 0 && (e = !1), t !== null)
+      if (this.cancelNextCallback(), t === m) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var r = this.props.nodeRef ? this.props.nodeRef.current : N.findDOMNode(this);
+          r && H(r);
+        }
+        this.performEnter(e);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === d && this.setState({
+      status: x
+    });
+  }, u.performEnter = function(e) {
+    var t = this, r = this.props.enter, o = this.context ? this.context.isMounting : e, p = this.props.nodeRef ? [o] : [N.findDOMNode(this), o], c = p[0], f = p[1], g = this.getTimeouts(), A = o ? g.appear : g.enter;
+    if (!e && !r || C.disabled) {
+      this.safeSetState({
+        status: E
+      }, function() {
+        t.props.onEntered(c);
+      });
+      return;
+    }
+    this.props.onEnter(c, f), this.safeSetState({
+      status: m
+    }, function() {
+      t.props.onEntering(c, f), t.onTransitionEnd(A, function() {
+        t.safeSetState({
+          status: E
+        }, function() {
+          t.props.onEntered(c, f);
+        });
+      });
+    });
+  }, u.performExit = function() {
+    var e = this, t = this.props.exit, r = this.getTimeouts(), o = this.props.nodeRef ? void 0 : N.findDOMNode(this);
+    if (!t || C.disabled) {
+      this.safeSetState({
+        status: d
+      }, function() {
+        e.props.onExited(o);
+      });
+      return;
+    }
+    this.props.onExit(o), this.safeSetState({
+      status: T
+    }, function() {
+      e.props.onExiting(o), e.onTransitionEnd(r.exit, function() {
+        e.safeSetState({
+          status: d
+        }, function() {
+          e.props.onExited(o);
+        });
+      });
+    });
+  }, u.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, u.safeSetState = function(e, t) {
+    t = this.setNextCallback(t), this.setState(e, t);
+  }, u.setNextCallback = function(e) {
+    var t = this, r = !0;
+    return this.nextCallback = function(o) {
+      r && (r = !1, t.nextCallback = null, e(o));
+    }, this.nextCallback.cancel = function() {
+      r = !1;
+    }, this.nextCallback;
+  }, u.onTransitionEnd = function(e, t) {
+    this.setNextCallback(t);
+    var r = this.props.nodeRef ? this.props.nodeRef.current : N.findDOMNode(this), o = e == null && !this.props.addEndListener;
+    if (!r || o) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var p = this.props.nodeRef ? [this.nextCallback] : [r, this.nextCallback], c = p[0], f = p[1];
+      this.props.addEndListener(c, f);
+    }
+    e != null && setTimeout(this.nextCallback, e);
+  }, u.render = function() {
+    var e = this.state.status;
+    if (e === x)
+      return null;
+    var t = this.props, r = t.children;
+    t.in, t.mountOnEnter, t.unmountOnExit, t.appear, t.enter, t.exit, t.timeout, t.addEndListener, t.onEnter, t.onEntering, t.onEntered, t.onExit, t.onExiting, t.onExited, t.nodeRef;
+    var o = k(t, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ v.createElement(S.Provider, {
+        value: null
+      }, typeof r == "function" ? r(e, o) : v.cloneElement(v.Children.only(r), o))
+    );
+  }, i;
+})(v.Component);
+l.contextType = S;
+l.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A React reference to DOM element that need to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - 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: a.shape({
+    current: typeof Element > "u" ? a.any : function(s, i, u, n, e, t) {
+      var r = s[i];
+      return a.instanceOf(r && "ownerDocument" in r ? r.ownerDocument.defaultView.Element : Element)(s, i, u, n, e, t);
+    }
+  }),
+  /**
+   * 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 in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: a.oneOfType([a.func.isRequired, a.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: a.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: a.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: a.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: a.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: a.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: a.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: function(i) {
+    var u = q;
+    i.addEndListener || (u = u.isRequired);
+    for (var n = arguments.length, e = new Array(n > 1 ? n - 1 : 0), t = 1; t < n; t++)
+      e[t - 1] = arguments[t];
+    return u.apply(void 0, [i].concat(e));
+  },
+  /**
+   * 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.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: a.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.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: a.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.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: a.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.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: a.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: a.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: a.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: a.func
+} : {};
+function h() {
+}
+l.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: h,
+  onEntering: h,
+  onEntered: h,
+  onExit: h,
+  onExiting: h,
+  onExited: h
+};
+l.UNMOUNTED = x;
+l.EXITED = d;
+l.ENTERING = m;
+l.ENTERED = E;
+l.EXITING = T;
+function tt(s) {
+  const {
+    elementType: i,
+    externalSlotProps: u,
+    ownerState: n,
+    skipResolvingSlotProps: e = !1,
+    ...t
+  } = s, r = e ? {} : F(u, n), {
+    props: o,
+    internalRef: p
+  } = w({
+    ...t,
+    externalSlotProps: r
+  }), c = L(p, r?.ref, s.additionalProps?.ref);
+  return P(i, {
+    ...o,
+    ref: c
+  }, n);
+}
+const et = (s) => s.scrollTop;
+function nt(s, i) {
+  const {
+    timeout: u,
+    easing: n,
+    style: e = {}
+  } = s;
+  return {
+    duration: e.transitionDuration ?? (typeof u == "number" ? u : u[i.mode] || 0),
+    easing: e.transitionTimingFunction ?? (typeof n == "object" ? n[i.mode] : n),
+    delay: e.transitionDelay
+  };
+}
+const _ = /* @__PURE__ */ b.createContext(void 0);
+process.env.NODE_ENV !== "production" && (_.displayName = "FormControlContext");
+function rt() {
+  return b.useContext(_);
+}
+export {
+  _ as F,
+  l as T,
+  Q as a,
+  tt as b,
+  J as c,
+  rt as d,
+  U as e,
+  H as f,
+  nt as g,
+  Z as h,
+  Y as m,
+  et as r,
+  K as u
+};