@fangzsx/component-library 0.0.11 → 0.0.13

package/dist/components/RadioButtonGroup/index.js

@@ -0,0 +1,836 @@
+import { jsx as l, jsxs as I } from "react/jsx-runtime";
+import * as u from "react";
+import { useState as Z } from "react";
+import { f as X, c as lo, F as io, a as co, b as po } from "../../FormLabel-DKoCtSGZ.js";
+import { a as $, g as B, c as M, P as o } from "../../generateUtilityClasses-BCID9NF1.js";
+import { u as _, c as G, s as N, a as L, m as V, d as Y, r as oo, b as J, h as uo } from "../../useTimeout-BWi4JTOH.js";
+import { a as A, b as eo, u as fo } from "../../useSlot-S2pEBHE8.js";
+import { u as mo } from "../../useId-CK6Kn3Tn.js";
+import { T as K } from "../../Typography-B0rSrz7H.js";
+import { S as bo } from "../../SwitchBase-DStPyUhD.js";
+import { c as ro } from "../../createSvgIcon-Dj0SJuc1.js";
+function yo(e) {
+  return B("MuiFormControlLabel", e);
+}
+const E = $("MuiFormControlLabel", ["root", "labelPlacementStart", "labelPlacementTop", "labelPlacementBottom", "disabled", "label", "error", "required", "asterisk"]), ho = (e) => {
+  const {
+    classes: r,
+    disabled: t,
+    labelPlacement: s,
+    error: a,
+    required: i
+  } = e, p = {
+    root: ["root", t && "disabled", `labelPlacement${M(s)}`, a && "error", i && "required"],
+    label: ["label", t && "disabled"],
+    asterisk: ["asterisk", a && "error"]
+  };
+  return L(p, yo, r);
+}, go = N("label", {
+  name: "MuiFormControlLabel",
+  slot: "Root",
+  overridesResolver: (e, r) => {
+    const {
+      ownerState: t
+    } = e;
+    return [{
+      [`& .${E.label}`]: r.label
+    }, r.root, r[`labelPlacement${M(t.labelPlacement)}`]];
+  }
+})(V(({
+  theme: e
+}) => ({
+  display: "inline-flex",
+  alignItems: "center",
+  cursor: "pointer",
+  // For correct alignment with the text.
+  verticalAlign: "middle",
+  WebkitTapHighlightColor: "transparent",
+  marginLeft: -11,
+  marginRight: 16,
+  // used for row presentation of radio/checkbox
+  [`&.${E.disabled}`]: {
+    cursor: "default"
+  },
+  [`& .${E.label}`]: {
+    [`&.${E.disabled}`]: {
+      color: (e.vars || e).palette.text.disabled
+    }
+  },
+  variants: [{
+    props: {
+      labelPlacement: "start"
+    },
+    style: {
+      flexDirection: "row-reverse",
+      marginRight: -11
+    }
+  }, {
+    props: {
+      labelPlacement: "top"
+    },
+    style: {
+      flexDirection: "column-reverse"
+    }
+  }, {
+    props: {
+      labelPlacement: "bottom"
+    },
+    style: {
+      flexDirection: "column"
+    }
+  }, {
+    props: ({
+      labelPlacement: r
+    }) => r === "start" || r === "top" || r === "bottom",
+    style: {
+      marginLeft: 16
+      // used for row presentation of radio/checkbox
+    }
+  }]
+}))), Co = N("span", {
+  name: "MuiFormControlLabel",
+  slot: "Asterisk"
+})(V(({
+  theme: e
+}) => ({
+  [`&.${E.error}`]: {
+    color: (e.vars || e).palette.error.main
+  }
+}))), to = /* @__PURE__ */ u.forwardRef(function(r, t) {
+  const s = _({
+    props: r,
+    name: "MuiFormControlLabel"
+  }), {
+    checked: a,
+    className: i,
+    componentsProps: p = {},
+    control: c,
+    disabled: d,
+    disableTypography: m,
+    inputRef: f,
+    label: h,
+    labelPlacement: P = "end",
+    name: S,
+    onChange: R,
+    required: w,
+    slots: b = {},
+    slotProps: F = {},
+    value: n,
+    ...y
+  } = s, x = A(), j = d ?? c.props.disabled ?? x?.disabled, g = w ?? c.props.required, O = {
+    disabled: j,
+    required: g
+  };
+  ["checked", "name", "onChange", "value", "inputRef"].forEach((k) => {
+    typeof c.props[k] > "u" && typeof s[k] < "u" && (O[k] = s[k]);
+  });
+  const D = X({
+    props: s,
+    muiFormControl: x,
+    states: ["error"]
+  }), v = {
+    ...s,
+    disabled: j,
+    labelPlacement: P,
+    required: g,
+    error: D.error
+  }, T = ho(v), q = {
+    slots: b,
+    slotProps: {
+      ...p,
+      ...F
+    }
+  }, [U, z] = eo("typography", {
+    elementType: K,
+    externalForwardedProps: q,
+    ownerState: v
+  });
+  let C = h;
+  return C != null && C.type !== K && !m && (C = /* @__PURE__ */ l(U, {
+    component: "span",
+    ...z,
+    className: G(T.label, z?.className),
+    children: C
+  })), /* @__PURE__ */ I(go, {
+    className: G(T.root, i),
+    ownerState: v,
+    ref: t,
+    ...y,
+    children: [/* @__PURE__ */ u.cloneElement(c, O), g ? /* @__PURE__ */ I("div", {
+      children: [C, /* @__PURE__ */ I(Co, {
+        ownerState: v,
+        "aria-hidden": !0,
+        className: T.asterisk,
+        children: [" ", "*"]
+      })]
+    }) : C]
+  });
+});
+process.env.NODE_ENV !== "production" && (to.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, the component appears selected.
+   */
+  checked: o.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * @ignore
+   */
+  className: o.string,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  componentsProps: o.shape({
+    typography: o.object
+  }),
+  /**
+   * A control element. For instance, it can be a `Radio`, a `Switch` or a `Checkbox`.
+   */
+  control: o.element.isRequired,
+  /**
+   * If `true`, the control is disabled.
+   */
+  disabled: o.bool,
+  /**
+   * If `true`, the label is rendered as it is passed without an additional typography node.
+   */
+  disableTypography: o.bool,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: Y,
+  /**
+   * A text or an element to be used in an enclosing label element.
+   */
+  label: o.node,
+  /**
+   * The position of the label.
+   * @default 'end'
+   */
+  labelPlacement: o.oneOf(["bottom", "end", "start", "top"]),
+  /**
+   * @ignore
+   */
+  name: o.string,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: o.func,
+  /**
+   * If `true`, the label will indicate that the `input` is required.
+   */
+  required: o.bool,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: o.shape({
+    typography: o.oneOfType([o.func, o.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: o.shape({
+    typography: o.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: o.oneOfType([o.arrayOf(o.oneOfType([o.func, o.object, o.bool])), o.func, o.object]),
+  /**
+   * The value of the component.
+   */
+  value: o.any
+});
+const Ro = ro(/* @__PURE__ */ l("path", {
+  d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"
+}), "RadioButtonUnchecked"), vo = ro(/* @__PURE__ */ l("path", {
+  d: "M8.465 8.465C9.37 7.56 10.62 7 12 7C14.76 7 17 9.24 17 12C17 13.38 16.44 14.63 15.535 15.535C14.63 16.44 13.38 17 12 17C9.24 17 7 14.76 7 12C7 10.62 7.56 9.37 8.465 8.465Z"
+}), "RadioButtonChecked"), Po = N("span", {
+  name: "MuiRadioButtonIcon",
+  shouldForwardProp: oo
+})({
+  position: "relative",
+  display: "flex"
+}), So = N(Ro, {
+  name: "MuiRadioButtonIcon"
+})({
+  // Scale applied to prevent dot misalignment in Safari
+  transform: "scale(1)"
+}), wo = N(vo, {
+  name: "MuiRadioButtonIcon"
+})(V(({
+  theme: e
+}) => ({
+  left: 0,
+  position: "absolute",
+  transform: "scale(0)",
+  transition: e.transitions.create("transform", {
+    easing: e.transitions.easing.easeIn,
+    duration: e.transitions.duration.shortest
+  }),
+  variants: [{
+    props: {
+      checked: !0
+    },
+    style: {
+      transform: "scale(1)",
+      transition: e.transitions.create("transform", {
+        easing: e.transitions.easing.easeOut,
+        duration: e.transitions.duration.shortest
+      })
+    }
+  }]
+})));
+function H(e) {
+  const {
+    checked: r = !1,
+    classes: t = {},
+    fontSize: s
+  } = e, a = {
+    ...e,
+    checked: r
+  };
+  return /* @__PURE__ */ I(Po, {
+    className: t.root,
+    ownerState: a,
+    children: [/* @__PURE__ */ l(So, {
+      fontSize: s,
+      className: t.background,
+      ownerState: a
+    }), /* @__PURE__ */ l(wo, {
+      fontSize: s,
+      className: t.dot,
+      ownerState: a
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" && (H.propTypes = {
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: o.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense radio styling.
+   */
+  fontSize: o.oneOf(["small", "medium"])
+});
+const W = /* @__PURE__ */ u.createContext(void 0);
+process.env.NODE_ENV !== "production" && (W.displayName = "RadioGroupContext");
+function Fo() {
+  return u.useContext(W);
+}
+function To(e) {
+  return B("MuiRadio", e);
+}
+const Q = $("MuiRadio", ["root", "checked", "disabled", "colorPrimary", "colorSecondary", "sizeSmall"]), ko = (e) => {
+  const {
+    classes: r,
+    color: t,
+    size: s
+  } = e, a = {
+    root: ["root", `color${M(t)}`, s !== "medium" && `size${M(s)}`]
+  };
+  return {
+    ...r,
+    ...L(a, To, r)
+  };
+}, No = N(bo, {
+  shouldForwardProp: (e) => oo(e) || e === "classes",
+  name: "MuiRadio",
+  slot: "Root",
+  overridesResolver: (e, r) => {
+    const {
+      ownerState: t
+    } = e;
+    return [r.root, t.size !== "medium" && r[`size${M(t.size)}`], r[`color${M(t.color)}`]];
+  }
+})(V(({
+  theme: e
+}) => ({
+  color: (e.vars || e).palette.text.secondary,
+  [`&.${Q.disabled}`]: {
+    color: (e.vars || e).palette.action.disabled
+  },
+  variants: [{
+    props: {
+      color: "default",
+      disabled: !1,
+      disableRipple: !1
+    },
+    style: {
+      "&:hover": {
+        backgroundColor: e.alpha((e.vars || e).palette.action.active, (e.vars || e).palette.action.hoverOpacity)
+      }
+    }
+  }, ...Object.entries(e.palette).filter(J()).map(([r]) => ({
+    props: {
+      color: r,
+      disabled: !1,
+      disableRipple: !1
+    },
+    style: {
+      "&:hover": {
+        backgroundColor: e.alpha((e.vars || e).palette[r].main, (e.vars || e).palette.action.hoverOpacity)
+      }
+    }
+  })), ...Object.entries(e.palette).filter(J()).map(([r]) => ({
+    props: {
+      color: r,
+      disabled: !1
+    },
+    style: {
+      [`&.${Q.checked}`]: {
+        color: (e.vars || e).palette[r].main
+      }
+    }
+  })), {
+    // Should be last to override other colors
+    props: {
+      disableRipple: !1
+    },
+    style: {
+      // Reset on touch devices, it doesn't add specificity
+      "&:hover": {
+        "@media (hover: none)": {
+          backgroundColor: "transparent"
+        }
+      }
+    }
+  }]
+})));
+function xo(e, r) {
+  return typeof r == "object" && r !== null ? e === r : String(e) === String(r);
+}
+const Oo = /* @__PURE__ */ l(H, {
+  checked: !0
+}), Mo = /* @__PURE__ */ l(H, {}), so = /* @__PURE__ */ u.forwardRef(function(r, t) {
+  const s = _({
+    props: r,
+    name: "MuiRadio"
+  }), {
+    checked: a,
+    checkedIcon: i = Oo,
+    color: p = "primary",
+    icon: c = Mo,
+    name: d,
+    onChange: m,
+    size: f = "medium",
+    className: h,
+    disabled: P,
+    disableRipple: S = !1,
+    slots: R = {},
+    slotProps: w = {},
+    inputProps: b,
+    ...F
+  } = s, n = A();
+  let y = P;
+  n && typeof y > "u" && (y = n.disabled), y ??= !1;
+  const x = {
+    ...s,
+    disabled: y,
+    disableRipple: S,
+    color: p,
+    size: f
+  }, j = ko(x), g = Fo();
+  let O = a;
+  const D = lo(m, g && g.onChange);
+  let v = d;
+  g && (typeof O > "u" && (O = xo(g.value, s.value)), typeof v > "u" && (v = g.name));
+  const T = w.input ?? b, [q, U] = eo("root", {
+    ref: t,
+    elementType: No,
+    className: G(j.root, h),
+    shouldForwardComponentProp: !0,
+    externalForwardedProps: {
+      slots: R,
+      slotProps: w,
+      ...F
+    },
+    getSlotProps: (z) => ({
+      ...z,
+      onChange: (C, ...k) => {
+        z.onChange?.(C, ...k), D(C, ...k);
+      }
+    }),
+    ownerState: x,
+    additionalProps: {
+      type: "radio",
+      icon: /* @__PURE__ */ u.cloneElement(c, {
+        fontSize: c.props.fontSize ?? f
+      }),
+      checkedIcon: /* @__PURE__ */ u.cloneElement(i, {
+        fontSize: i.props.fontSize ?? f
+      }),
+      disabled: y,
+      name: v,
+      checked: O,
+      slots: R,
+      slotProps: {
+        // Do not forward `slotProps.root` again because it's already handled by the `RootSlot` in this file.
+        input: typeof T == "function" ? T(x) : T
+      }
+    }
+  });
+  return /* @__PURE__ */ l(q, {
+    ...U,
+    classes: j
+  });
+});
+process.env.NODE_ENV !== "production" && (so.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: o.bool,
+  /**
+   * The icon to display when the component is checked.
+   * @default <RadioButtonIcon checked />
+   */
+  checkedIcon: o.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * @ignore
+   */
+  className: o.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: o.oneOfType([o.oneOf(["default", "primary", "secondary", "error", "info", "success", "warning"]), o.string]),
+  /**
+   * If `true`, the component is disabled.
+   */
+  disabled: o.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   * @default false
+   */
+  disableRipple: o.bool,
+  /**
+   * The icon to display when the component is unchecked.
+   * @default <RadioButtonIcon />
+   */
+  icon: o.node,
+  /**
+   * The id of the `input` element.
+   */
+  id: o.string,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#attributes) applied to the `input` element.
+   * @deprecated Use `slotProps.input` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  inputProps: o.object,
+  /**
+   * Pass a ref to the `input` element.
+   * @deprecated Use `slotProps.input.ref` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  inputRef: Y,
+  /**
+   * Name attribute of the `input` element.
+   */
+  name: o.string,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (string).
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: o.func,
+  /**
+   * If `true`, the `input` element is required.
+   * @default false
+   */
+  required: o.bool,
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense radio styling.
+   * @default 'medium'
+   */
+  size: o.oneOfType([o.oneOf(["medium", "small"]), o.string]),
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: o.shape({
+    input: o.oneOfType([o.func, o.object]),
+    root: o.oneOfType([o.func, o.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: o.shape({
+    input: o.elementType,
+    root: o.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: o.oneOfType([o.arrayOf(o.oneOfType([o.func, o.object, o.bool])), o.func, o.object]),
+  /**
+   * The value of the component. The DOM API casts this to a string.
+   */
+  value: o.any
+});
+function jo(e) {
+  return B("MuiFormGroup", e);
+}
+$("MuiFormGroup", ["root", "row", "error"]);
+const zo = (e) => {
+  const {
+    classes: r,
+    row: t,
+    error: s
+  } = e;
+  return L({
+    root: ["root", t && "row", s && "error"]
+  }, jo, r);
+}, Eo = N("div", {
+  name: "MuiFormGroup",
+  slot: "Root",
+  overridesResolver: (e, r) => {
+    const {
+      ownerState: t
+    } = e;
+    return [r.root, t.row && r.row];
+  }
+})({
+  display: "flex",
+  flexDirection: "column",
+  flexWrap: "wrap",
+  variants: [{
+    props: {
+      row: !0
+    },
+    style: {
+      flexDirection: "row"
+    }
+  }]
+}), ao = /* @__PURE__ */ u.forwardRef(function(r, t) {
+  const s = _({
+    props: r,
+    name: "MuiFormGroup"
+  }), {
+    className: a,
+    row: i = !1,
+    ...p
+  } = s, c = A(), d = X({
+    props: s,
+    muiFormControl: c,
+    states: ["error"]
+  }), m = {
+    ...s,
+    row: i,
+    error: d.error
+  }, f = zo(m);
+  return /* @__PURE__ */ l(Eo, {
+    className: G(f.root, a),
+    ownerState: m,
+    ref: t,
+    ...p
+  });
+});
+process.env.NODE_ENV !== "production" && (ao.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: o.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * @ignore
+   */
+  className: o.string,
+  /**
+   * Display group of elements in a compact row.
+   * @default false
+   */
+  row: o.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: o.oneOfType([o.arrayOf(o.oneOfType([o.func, o.object, o.bool])), o.func, o.object])
+});
+function Io(e) {
+  return B("MuiRadioGroup", e);
+}
+$("MuiRadioGroup", ["root", "row", "error"]);
+const Go = (e) => {
+  const {
+    classes: r,
+    row: t,
+    error: s
+  } = e;
+  return L({
+    root: ["root", t && "row", s && "error"]
+  }, Io, r);
+}, no = /* @__PURE__ */ u.forwardRef(function(r, t) {
+  const {
+    // private
+    // eslint-disable-next-line react/prop-types
+    actions: s,
+    children: a,
+    className: i,
+    defaultValue: p,
+    name: c,
+    onChange: d,
+    value: m,
+    ...f
+  } = r, h = u.useRef(null), P = Go(r), [S, R] = fo({
+    controlled: m,
+    default: p,
+    name: "RadioGroup"
+  });
+  u.useImperativeHandle(s, () => ({
+    focus: () => {
+      let n = h.current.querySelector("input:not(:disabled):checked");
+      n || (n = h.current.querySelector("input:not(:disabled)")), n && n.focus();
+    }
+  }), []);
+  const w = uo(t, h), b = mo(c), F = u.useMemo(() => ({
+    name: b,
+    onChange(n) {
+      R(n.target.value), d && d(n, n.target.value);
+    },
+    value: S
+  }), [b, d, R, S]);
+  return /* @__PURE__ */ l(W.Provider, {
+    value: F,
+    children: /* @__PURE__ */ l(ao, {
+      role: "radiogroup",
+      ref: w,
+      className: G(P.root, i),
+      ...f,
+      children: a
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (no.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: o.node,
+  /**
+   * @ignore
+   */
+  className: o.string,
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: o.any,
+  /**
+   * The name used to reference the value of the control.
+   * If you don't provide this prop, it falls back to a randomly generated name.
+   */
+  name: o.string,
+  /**
+   * Callback fired when a radio button is selected.
+   *
+   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
+   * @param {string} value The value of the selected radio button.
+   * You can pull out the new value by accessing `event.target.value` (string).
+   */
+  onChange: o.func,
+  /**
+   * Value of the selected radio button. The DOM API casts this to a string.
+   */
+  value: o.any
+});
+function Wo({
+  label: e,
+  options: r,
+  defaultValue: t,
+  required: s = !1,
+  errorMessage: a = "Please select an option",
+  helperText: i,
+  onChange: p,
+  row: c = !1,
+  direction: d,
+  sx: m
+}) {
+  const [f, h] = Z(t || ""), [P, S] = Z(!1), R = (n) => {
+    const y = n.target.value;
+    h(y), S(!0), p && p(y);
+  }, b = P && s && f === "", F = d ? d === "row" : c;
+  return /* @__PURE__ */ I(
+    io,
+    {
+      error: b,
+      required: s,
+      sx: {
+        "& .MuiFormHelperText-root": {
+          marginLeft: 0,
+          marginRight: 0
+        },
+        ...m
+      },
+      children: [
+        e && /* @__PURE__ */ l(co, { children: e }),
+        /* @__PURE__ */ l(
+          no,
+          {
+            value: f,
+            onChange: R,
+            row: F,
+            children: r.map((n) => /* @__PURE__ */ l(
+              to,
+              {
+                value: n.value,
+                control: /* @__PURE__ */ l(so, {}),
+                label: n.label,
+                sx: {
+                  "& .MuiFormControlLabel-label": {
+                    color: "#404A58",
+                    fontSize: "16px"
+                  }
+                }
+              },
+              n.value
+            ))
+          }
+        ),
+        (b || i) && /* @__PURE__ */ l(po, { children: b ? a : i || " " })
+      ]
+    }
+  );
+}
+export {
+  Wo as RadioButtonGroup
+};