@sisense/sdk-shared-ui 1.27.1 → 1.29.0

package/dist/ButtonBase-DPVWpC8-.js

@@ -0,0 +1,883 @@
+var Se = Object.defineProperty;
+var ve = (o, e, n) => e in o ? Se(o, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : o[e] = n;
+var re = (o, e, n) => ve(o, typeof e != "symbol" ? e + "" : e, n);
+import * as d from "react";
+import H, { Children as Be, isValidElement as W, cloneElement as G } from "react";
+import { P as t } from "./index-D0lMis-I.js";
+import { f as E, b as ce, p as te, s as ne, e as pe, g as Le, h as $e } from "./ThemeProvider-BCsnqK18.js";
+import { jsx as I, jsxs as ke } from "react/jsx-runtime";
+import { c as Oe, a as Fe, _ as je, T as ae, b as Ie, u as le, d as J, i as ue, r as Ue } from "./useTimeout-BG7TPjEm.js";
+import { _ as ze } from "./setPrototypeOf-CEtRTXk2.js";
+import { _ as _e } from "./extends-DX42hfxm.js";
+import { _ as Ae } from "./assertThisInitialized-lz6cHcRv.js";
+function Xe(o) {
+  const {
+    prototype: e = {}
+  } = o;
+  return !!e.isReactComponent;
+}
+function Ye(o, e, n, l, i) {
+  const s = o[e], r = i || e;
+  if (s == null || // When server-side rendering React doesn't warn either.
+  // This is not an accurate check for SSR.
+  // This is only in place for emotion compat.
+  // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
+  typeof window > "u")
+    return null;
+  let u;
+  return typeof s == "function" && !Xe(s) && (u = "Did you accidentally provide a plain function component instead?"), u !== void 0 ? new Error(`Invalid ${l} \`${r}\` supplied to \`${n}\`. Expected an element type that can hold a ref. ${u} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const Ke = Oe(t.elementType, Ye);
+class Q {
+  constructor() {
+    re(this, "mountEffect", () => {
+      this.shouldMount && !this.didMount && this.ref.current !== null && (this.didMount = !0, this.mounted.resolve());
+    });
+    this.ref = {
+      current: null
+    }, this.mounted = null, this.didMount = !1, this.shouldMount = !1, this.setShouldMount = null;
+  }
+  /** React ref to the ripple instance */
+  /** If the ripple component should be mounted */
+  /** Promise that resolves when the ripple component is mounted */
+  /** If the ripple component has been mounted */
+  /** React state hook setter */
+  static create() {
+    return new Q();
+  }
+  static use() {
+    const e = Fe(Q.create).current, [n, l] = d.useState(!1);
+    return e.shouldMount = n, e.setShouldMount = l, d.useEffect(e.mountEffect, [n]), e;
+  }
+  mount() {
+    return this.mounted || (this.mounted = He(), this.shouldMount = !0, this.setShouldMount(this.shouldMount)), this.mounted;
+  }
+  /* Ripple API */
+  start(...e) {
+    this.mount().then(() => {
+      var n;
+      return (n = this.ref.current) == null ? void 0 : n.start(...e);
+    });
+  }
+  stop(...e) {
+    this.mount().then(() => {
+      var n;
+      return (n = this.ref.current) == null ? void 0 : n.stop(...e);
+    });
+  }
+  pulsate(...e) {
+    this.mount().then(() => {
+      var n;
+      return (n = this.ref.current) == null ? void 0 : n.pulsate(...e);
+    });
+  }
+}
+function qe() {
+  return Q.use();
+}
+function He() {
+  let o, e;
+  const n = new Promise((l, i) => {
+    o = l, e = i;
+  });
+  return n.resolve = o, n.reject = e, n;
+}
+function oe(o, e) {
+  var n = function(s) {
+    return e && W(s) ? e(s) : s;
+  }, l = /* @__PURE__ */ Object.create(null);
+  return o && Be.map(o, function(i) {
+    return i;
+  }).forEach(function(i) {
+    l[i.key] = n(i);
+  }), l;
+}
+function We(o, e) {
+  o = o || {}, e = e || {};
+  function n(h) {
+    return h in e ? e[h] : o[h];
+  }
+  var l = /* @__PURE__ */ Object.create(null), i = [];
+  for (var s in o)
+    s in e ? i.length && (l[s] = i, i = []) : i.push(s);
+  var r, u = {};
+  for (var c in e) {
+    if (l[c])
+      for (r = 0; r < l[c].length; r++) {
+        var f = l[c][r];
+        u[l[c][r]] = n(f);
+      }
+    u[c] = n(c);
+  }
+  for (r = 0; r < i.length; r++)
+    u[i[r]] = n(i[r]);
+  return u;
+}
+function k(o, e, n) {
+  return n[e] != null ? n[e] : o.props[e];
+}
+function Ge(o, e) {
+  return oe(o.children, function(n) {
+    return G(n, {
+      onExited: e.bind(null, n),
+      in: !0,
+      appear: k(n, "appear", o),
+      enter: k(n, "enter", o),
+      exit: k(n, "exit", o)
+    });
+  });
+}
+function Je(o, e, n) {
+  var l = oe(o.children), i = We(e, l);
+  return Object.keys(i).forEach(function(s) {
+    var r = i[s];
+    if (W(r)) {
+      var u = s in e, c = s in l, f = e[s], h = W(f) && !f.props.in;
+      c && (!u || h) ? i[s] = G(r, {
+        onExited: n.bind(null, r),
+        in: !0,
+        exit: k(r, "exit", o),
+        enter: k(r, "enter", o)
+      }) : !c && u && !h ? i[s] = G(r, {
+        in: !1
+      }) : c && u && W(f) && (i[s] = G(r, {
+        onExited: n.bind(null, r),
+        in: f.props.in,
+        exit: k(r, "exit", o),
+        enter: k(r, "enter", o)
+      }));
+    }
+  }), i;
+}
+var Qe = Object.values || function(o) {
+  return Object.keys(o).map(function(e) {
+    return o[e];
+  });
+}, Ze = {
+  component: "div",
+  childFactory: function(e) {
+    return e;
+  }
+}, ie = /* @__PURE__ */ function(o) {
+  je(e, o);
+  function e(l, i) {
+    var s;
+    s = o.call(this, l, i) || this;
+    var r = s.handleExited.bind(Ae(s));
+    return s.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: r,
+      firstRender: !0
+    }, s;
+  }
+  var n = e.prototype;
+  return n.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, n.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, e.getDerivedStateFromProps = function(i, s) {
+    var r = s.children, u = s.handleExited, c = s.firstRender;
+    return {
+      children: c ? Ge(i, u) : Je(i, r, u),
+      firstRender: !1
+    };
+  }, n.handleExited = function(i, s) {
+    var r = oe(this.props.children);
+    i.key in r || (i.props.onExited && i.props.onExited(s), this.mounted && this.setState(function(u) {
+      var c = _e({}, u.children);
+      return delete c[i.key], {
+        children: c
+      };
+    }));
+  }, n.render = function() {
+    var i = this.props, s = i.component, r = i.childFactory, u = ze(i, ["component", "childFactory"]), c = this.state.contextValue, f = Qe(this.state.children).map(r);
+    return delete u.appear, delete u.enter, delete u.exit, s === null ? /* @__PURE__ */ H.createElement(ae.Provider, {
+      value: c
+    }, f) : /* @__PURE__ */ H.createElement(ae.Provider, {
+      value: c
+    }, /* @__PURE__ */ H.createElement(s, u, f));
+  }, e;
+}(H.Component);
+ie.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * `<TransitionGroup>` renders a `<div>` by default. You can change this
+   * behavior by providing a `component` prop.
+   * If you use React v16+ and would like to avoid a wrapping `<div>` element
+   * you can pass in `component={null}`. This is useful if the wrapping div
+   * borks your css styles.
+   */
+  component: t.any,
+  /**
+   * A set of `<Transition>` components, that are toggled `in` and out as they
+   * leave. the `<TransitionGroup>` will inject specific transition props, so
+   * remember to spread them through if you are wrapping the `<Transition>` as
+   * with our `<Fade>` example.
+   *
+   * While this component is meant for multiple `Transition` or `CSSTransition`
+   * children, sometimes you may want to have a single transition child with
+   * content that you want to be transitioned out and in when you change it
+   * (e.g. routes, images etc.) In that case you can change the `key` prop of
+   * the transition child as you change its content, this will cause
+   * `TransitionGroup` to transition the child out and back in.
+   */
+  children: t.node,
+  /**
+   * A convenience prop that enables or disables appear animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  appear: t.bool,
+  /**
+   * A convenience prop that enables or disables enter animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  enter: t.bool,
+  /**
+   * A convenience prop that enables or disables exit animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  exit: t.bool,
+  /**
+   * You may need to apply reactive updates to a child as it is exiting.
+   * This is generally done by using `cloneElement` however in the case of an exiting
+   * child the element has already been removed and not accessible to the consumer.
+   *
+   * If you do need to update a child as it leaves you can provide a `childFactory`
+   * to wrap every child, even the ones that are leaving.
+   *
+   * @type Function(child: ReactElement) -> ReactElement
+   */
+  childFactory: t.func
+} : {};
+ie.defaultProps = Ze;
+function fe(o) {
+  const {
+    className: e,
+    classes: n,
+    pulsate: l = !1,
+    rippleX: i,
+    rippleY: s,
+    rippleSize: r,
+    in: u,
+    onExited: c,
+    timeout: f
+  } = o, [h, m] = d.useState(!1), M = E(e, n.ripple, n.rippleVisible, l && n.ripplePulsate), N = {
+    width: r,
+    height: r,
+    top: -(r / 2) + s,
+    left: -(r / 2) + i
+  }, g = E(n.child, h && n.childLeaving, l && n.childPulsate);
+  return !u && !h && m(!0), d.useEffect(() => {
+    if (!u && c != null) {
+      const v = setTimeout(c, f);
+      return () => {
+        clearTimeout(v);
+      };
+    }
+  }, [c, u, f]), /* @__PURE__ */ I("span", {
+    className: M,
+    style: N,
+    children: /* @__PURE__ */ I("span", {
+      className: g
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (fe.propTypes = {
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object.isRequired,
+  className: t.string,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  in: t.bool,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  onExited: t.func,
+  /**
+   * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
+   */
+  pulsate: t.bool,
+  /**
+   * Diameter of the ripple.
+   */
+  rippleSize: t.number,
+  /**
+   * Horizontal position of the ripple center.
+   */
+  rippleX: t.number,
+  /**
+   * Vertical position of the ripple center.
+   */
+  rippleY: t.number,
+  /**
+   * exit delay
+   */
+  timeout: t.number.isRequired
+});
+const y = ce("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), ee = 550, et = 80, tt = te`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`, nt = te`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`, ot = te`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`, it = ne("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), st = ne(fe, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})`
+  opacity: 0;
+  position: absolute;
+
+  &.${y.rippleVisible} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${tt};
+    animation-duration: ${ee}ms;
+    animation-timing-function: ${({
+  theme: o
+}) => o.transitions.easing.easeInOut};
+  }
+
+  &.${y.ripplePulsate} {
+    animation-duration: ${({
+  theme: o
+}) => o.transitions.duration.shorter}ms;
+  }
+
+  & .${y.child} {
+    opacity: 1;
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    background-color: currentColor;
+  }
+
+  & .${y.childLeaving} {
+    opacity: 0;
+    animation-name: ${nt};
+    animation-duration: ${ee}ms;
+    animation-timing-function: ${({
+  theme: o
+}) => o.transitions.easing.easeInOut};
+  }
+
+  & .${y.childPulsate} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${ot};
+    animation-duration: 2500ms;
+    animation-timing-function: ${({
+  theme: o
+}) => o.transitions.easing.easeInOut};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`, de = /* @__PURE__ */ d.forwardRef(function(e, n) {
+  const l = pe({
+    props: e,
+    name: "MuiTouchRipple"
+  }), {
+    center: i = !1,
+    classes: s = {},
+    className: r,
+    ...u
+  } = l, [c, f] = d.useState([]), h = d.useRef(0), m = d.useRef(null);
+  d.useEffect(() => {
+    m.current && (m.current(), m.current = null);
+  }, [c]);
+  const M = d.useRef(!1), N = Ie(), g = d.useRef(null), v = d.useRef(null), x = d.useCallback((p) => {
+    const {
+      pulsate: T,
+      rippleX: R,
+      rippleY: j,
+      rippleSize: B,
+      cb: U
+    } = p;
+    f((C) => [...C, /* @__PURE__ */ I(st, {
+      classes: {
+        ripple: E(s.ripple, y.ripple),
+        rippleVisible: E(s.rippleVisible, y.rippleVisible),
+        ripplePulsate: E(s.ripplePulsate, y.ripplePulsate),
+        child: E(s.child, y.child),
+        childLeaving: E(s.childLeaving, y.childLeaving),
+        childPulsate: E(s.childPulsate, y.childPulsate)
+      },
+      timeout: ee,
+      pulsate: T,
+      rippleX: R,
+      rippleY: j,
+      rippleSize: B
+    }, h.current)]), h.current += 1, m.current = U;
+  }, [s]), O = d.useCallback((p = {}, T = {}, R = () => {
+  }) => {
+    const {
+      pulsate: j = !1,
+      center: B = i || T.pulsate,
+      fakeElement: U = !1
+      // For test purposes
+    } = T;
+    if ((p == null ? void 0 : p.type) === "mousedown" && M.current) {
+      M.current = !1;
+      return;
+    }
+    (p == null ? void 0 : p.type) === "touchstart" && (M.current = !0);
+    const C = U ? null : v.current, V = C ? C.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let w, P, S;
+    if (B || p === void 0 || p.clientX === 0 && p.clientY === 0 || !p.clientX && !p.touches)
+      w = Math.round(V.width / 2), P = Math.round(V.height / 2);
+    else {
+      const {
+        clientX: z,
+        clientY: L
+      } = p.touches && p.touches.length > 0 ? p.touches[0] : p;
+      w = Math.round(z - V.left), P = Math.round(L - V.top);
+    }
+    if (B)
+      S = Math.sqrt((2 * V.width ** 2 + V.height ** 2) / 3), S % 2 === 0 && (S += 1);
+    else {
+      const z = Math.max(Math.abs((C ? C.clientWidth : 0) - w), w) * 2 + 2, L = Math.max(Math.abs((C ? C.clientHeight : 0) - P), P) * 2 + 2;
+      S = Math.sqrt(z ** 2 + L ** 2);
+    }
+    p != null && p.touches ? g.current === null && (g.current = () => {
+      x({
+        pulsate: j,
+        rippleX: w,
+        rippleY: P,
+        rippleSize: S,
+        cb: R
+      });
+    }, N.start(et, () => {
+      g.current && (g.current(), g.current = null);
+    })) : x({
+      pulsate: j,
+      rippleX: w,
+      rippleY: P,
+      rippleSize: S,
+      cb: R
+    });
+  }, [i, x, N]), Y = d.useCallback(() => {
+    O({}, {
+      pulsate: !0
+    });
+  }, [O]), F = d.useCallback((p, T) => {
+    if (N.clear(), (p == null ? void 0 : p.type) === "touchend" && g.current) {
+      g.current(), g.current = null, N.start(0, () => {
+        F(p, T);
+      });
+      return;
+    }
+    g.current = null, f((R) => R.length > 0 ? R.slice(1) : R), m.current = T;
+  }, [N]);
+  return d.useImperativeHandle(n, () => ({
+    pulsate: Y,
+    start: O,
+    stop: F
+  }), [Y, O, F]), /* @__PURE__ */ I(it, {
+    className: E(y.root, s.root, r),
+    ref: v,
+    ...u,
+    children: /* @__PURE__ */ I(ie, {
+      component: null,
+      exit: !0,
+      children: c
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (de.propTypes = {
+  /**
+   * If `true`, the ripple starts at the center of the component
+   * rather than at the point of interaction.
+   */
+  center: t.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string
+});
+function rt(o) {
+  return Le("MuiButtonBase", o);
+}
+const at = ce("MuiButtonBase", ["root", "disabled", "focusVisible"]), lt = (o) => {
+  const {
+    disabled: e,
+    focusVisible: n,
+    focusVisibleClassName: l,
+    classes: i
+  } = o, r = $e({
+    root: ["root", e && "disabled", n && "focusVisible"]
+  }, rt, i);
+  return n && l && (r.root += ` ${l}`), r;
+}, ut = ne("button", {
+  name: "MuiButtonBase",
+  slot: "Root",
+  overridesResolver: (o, e) => e.root
+})({
+  display: "inline-flex",
+  alignItems: "center",
+  justifyContent: "center",
+  position: "relative",
+  boxSizing: "border-box",
+  WebkitTapHighlightColor: "transparent",
+  backgroundColor: "transparent",
+  // Reset default value
+  // We disable the focus ring for mouse, touch and keyboard users.
+  outline: 0,
+  border: 0,
+  margin: 0,
+  // Remove the margin in Safari
+  borderRadius: 0,
+  padding: 0,
+  // Remove the padding in Firefox
+  cursor: "pointer",
+  userSelect: "none",
+  verticalAlign: "middle",
+  MozAppearance: "none",
+  // Reset
+  WebkitAppearance: "none",
+  // Reset
+  textDecoration: "none",
+  // So we take precedent over the style of a native <a /> element.
+  color: "inherit",
+  "&::-moz-focus-inner": {
+    borderStyle: "none"
+    // Remove Firefox dotted outline.
+  },
+  [`&.${at.disabled}`]: {
+    pointerEvents: "none",
+    // Disable link interactions
+    cursor: "default"
+  },
+  "@media print": {
+    colorAdjust: "exact"
+  }
+}), ct = /* @__PURE__ */ d.forwardRef(function(e, n) {
+  const l = pe({
+    props: e,
+    name: "MuiButtonBase"
+  }), {
+    action: i,
+    centerRipple: s = !1,
+    children: r,
+    className: u,
+    component: c = "button",
+    disabled: f = !1,
+    disableRipple: h = !1,
+    disableTouchRipple: m = !1,
+    focusRipple: M = !1,
+    focusVisibleClassName: N,
+    LinkComponent: g = "a",
+    onBlur: v,
+    onClick: x,
+    onContextMenu: O,
+    onDragLeave: Y,
+    onFocus: F,
+    onFocusVisible: p,
+    onKeyDown: T,
+    onKeyUp: R,
+    onMouseDown: j,
+    onMouseLeave: B,
+    onMouseUp: U,
+    onTouchEnd: C,
+    onTouchMove: V,
+    onTouchStart: w,
+    tabIndex: P = 0,
+    TouchRippleProps: S,
+    touchRippleRef: z,
+    type: L,
+    ..._
+  } = l, A = d.useRef(null), b = qe(), he = le(b.ref, z), [$, K] = d.useState(!1);
+  f && $ && K(!1), d.useImperativeHandle(i, () => ({
+    focusVisible: () => {
+      K(!0), A.current.focus();
+    }
+  }), []);
+  const me = b.shouldMount && !h && !f;
+  d.useEffect(() => {
+    $ && M && !h && b.pulsate();
+  }, [h, M, $, b]);
+  const be = D(b, "start", j, m), ge = D(b, "stop", O, m), ye = D(b, "stop", Y, m), Me = D(b, "stop", U, m), Re = D(b, "stop", (a) => {
+    $ && a.preventDefault(), B && B(a);
+  }, m), Te = D(b, "start", w, m), Ce = D(b, "stop", C, m), Ee = D(b, "stop", V, m), xe = D(b, "stop", (a) => {
+    ue(a.target) || K(!1), v && v(a);
+  }, !1), Pe = J((a) => {
+    A.current || (A.current = a.currentTarget), ue(a.target) && (K(!0), p && p(a)), F && F(a);
+  }), Z = () => {
+    const a = A.current;
+    return c && c !== "button" && !(a.tagName === "A" && a.href);
+  }, De = J((a) => {
+    M && !a.repeat && $ && a.key === " " && b.stop(a, () => {
+      b.start(a);
+    }), a.target === a.currentTarget && Z() && a.key === " " && a.preventDefault(), T && T(a), a.target === a.currentTarget && Z() && a.key === "Enter" && !f && (a.preventDefault(), x && x(a));
+  }), Ne = J((a) => {
+    M && a.key === " " && $ && !a.defaultPrevented && b.stop(a, () => {
+      b.pulsate(a);
+    }), R && R(a), x && a.target === a.currentTarget && Z() && a.key === " " && !a.defaultPrevented && x(a);
+  });
+  let q = c;
+  q === "button" && (_.href || _.to) && (q = g);
+  const X = {};
+  q === "button" ? (X.type = L === void 0 ? "button" : L, X.disabled = f) : (!_.href && !_.to && (X.role = "button"), f && (X["aria-disabled"] = f));
+  const Ve = le(n, A), se = {
+    ...l,
+    centerRipple: s,
+    component: c,
+    disabled: f,
+    disableRipple: h,
+    disableTouchRipple: m,
+    focusRipple: M,
+    tabIndex: P,
+    focusVisible: $
+  }, we = lt(se);
+  return /* @__PURE__ */ ke(ut, {
+    as: q,
+    className: E(we.root, u),
+    ownerState: se,
+    onBlur: xe,
+    onClick: x,
+    onContextMenu: ge,
+    onFocus: Pe,
+    onKeyDown: De,
+    onKeyUp: Ne,
+    onMouseDown: be,
+    onMouseLeave: Re,
+    onMouseUp: Me,
+    onDragLeave: ye,
+    onTouchEnd: Ce,
+    onTouchMove: Ee,
+    onTouchStart: Te,
+    ref: Ve,
+    tabIndex: f ? -1 : P,
+    type: L,
+    ...X,
+    ..._,
+    children: [r, me ? /* @__PURE__ */ I(de, {
+      ref: he,
+      center: s,
+      ...S
+    }) : null]
+  });
+});
+function D(o, e, n, l = !1) {
+  return J((i) => (n && n(i), l || o[e](i), !0));
+}
+process.env.NODE_ENV !== "production" && (ct.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * A ref for imperative actions.
+   * It currently only supports `focusVisible()` action.
+   */
+  action: Ue,
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: t.bool,
+  /**
+   * The content of the component.
+   */
+  children: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: Ke,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: t.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   *
+   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
+   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
+   * @default false
+   */
+  disableRipple: t.bool,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: t.bool,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: t.bool,
+  /**
+   * This prop can help identify which element has keyboard focus.
+   * The class name will be applied when the element gains the focus through keyboard interaction.
+   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
+   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
+   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
+   * if needed.
+   */
+  focusVisibleClassName: t.string,
+  /**
+   * @ignore
+   */
+  href: t.any,
+  /**
+   * The component used to render a link when the `href` prop is provided.
+   * @default 'a'
+   */
+  LinkComponent: t.elementType,
+  /**
+   * @ignore
+   */
+  onBlur: t.func,
+  /**
+   * @ignore
+   */
+  onClick: t.func,
+  /**
+   * @ignore
+   */
+  onContextMenu: t.func,
+  /**
+   * @ignore
+   */
+  onDragLeave: t.func,
+  /**
+   * @ignore
+   */
+  onFocus: t.func,
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: t.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: t.func,
+  /**
+   * @ignore
+   */
+  onKeyUp: t.func,
+  /**
+   * @ignore
+   */
+  onMouseDown: t.func,
+  /**
+   * @ignore
+   */
+  onMouseLeave: t.func,
+  /**
+   * @ignore
+   */
+  onMouseUp: t.func,
+  /**
+   * @ignore
+   */
+  onTouchEnd: t.func,
+  /**
+   * @ignore
+   */
+  onTouchMove: t.func,
+  /**
+   * @ignore
+   */
+  onTouchStart: t.func,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * @default 0
+   */
+  tabIndex: t.number,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: t.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: t.oneOfType([t.func, t.shape({
+    current: t.shape({
+      pulsate: t.func.isRequired,
+      start: t.func.isRequired,
+      stop: t.func.isRequired
+    })
+  })]),
+  /**
+   * @ignore
+   */
+  type: t.oneOfType([t.oneOf(["button", "reset", "submit"]), t.string])
+});
+export {
+  ct as B,
+  Ke as e
+};