everest-npm-features 0.0.1 → 0.0.2

package/dist/FormControlLabel-BMeMEwyK.js

@@ -0,0 +1,738 @@
+import * as S from "react";
+import { g as H, P as e, f as g, a as X } from "./createTheme-F9Dk4FhK.js";
+import { g as A, s as T, r as ee, c as j, a as _, m as W, u as oe } from "./DefaultPropsProvider-DmUB0SYC.js";
+import { u as te, f as ae } from "./useFormControl-CfmEP6sW.js";
+import { jsxs as L, jsx as u } from "react/jsx-runtime";
+import { B as ne } from "./ButtonBase-AOLUTpPg.js";
+import { u as le } from "./useControlled-BYdyS7Pn.js";
+import { r as G } from "./useTimeout-D29bZ7Gz.js";
+import { c as J } from "./createSvgIcon-jkXneOQN.js";
+import { c as Y } from "./createSimplePaletteValueFilter-B7--0ryQ.js";
+import { u as ce } from "./useSlot-DaP6eodX.js";
+import { T as Z } from "./Typography-Dx54MRM5.js";
+function ie(o) {
+  return H("PrivateSwitchBase", o);
+}
+A("PrivateSwitchBase", ["root", "checked", "disabled", "input", "edgeStart", "edgeEnd"]);
+const de = (o) => {
+  const {
+    classes: t,
+    checked: r,
+    disabled: s,
+    edge: a
+  } = o, l = {
+    root: ["root", r && "checked", s && "disabled", a && `edge${g(a)}`],
+    input: ["input"]
+  };
+  return _(l, ie, t);
+}, pe = T(ne)({
+  padding: 9,
+  borderRadius: "50%",
+  variants: [{
+    props: {
+      edge: "start",
+      size: "small"
+    },
+    style: {
+      marginLeft: -3
+    }
+  }, {
+    props: ({
+      edge: o,
+      ownerState: t
+    }) => o === "start" && t.size !== "small",
+    style: {
+      marginLeft: -12
+    }
+  }, {
+    props: {
+      edge: "end",
+      size: "small"
+    },
+    style: {
+      marginRight: -3
+    }
+  }, {
+    props: ({
+      edge: o,
+      ownerState: t
+    }) => o === "end" && t.size !== "small",
+    style: {
+      marginRight: -12
+    }
+  }]
+}), ue = T("input", {
+  shouldForwardProp: ee
+})({
+  cursor: "inherit",
+  position: "absolute",
+  opacity: 0,
+  width: "100%",
+  height: "100%",
+  top: 0,
+  left: 0,
+  margin: 0,
+  padding: 0,
+  zIndex: 1
+}), re = /* @__PURE__ */ S.forwardRef(function(t, r) {
+  const {
+    autoFocus: s,
+    checked: a,
+    checkedIcon: l,
+    className: d,
+    defaultChecked: n,
+    disabled: C,
+    disableFocusRipple: k = !1,
+    edge: v = !1,
+    icon: w,
+    id: F,
+    inputProps: $,
+    inputRef: O,
+    name: P,
+    onBlur: f,
+    onChange: h,
+    onFocus: q,
+    readOnly: M,
+    required: x = !1,
+    tabIndex: N,
+    type: b,
+    value: B,
+    ...E
+  } = t, [y, I] = le({
+    controlled: a,
+    default: !!n,
+    name: "SwitchBase",
+    state: "checked"
+  }), c = te(), U = (p) => {
+    q && q(p), c && c.onFocus && c.onFocus(p);
+  }, R = (p) => {
+    f && f(p), c && c.onBlur && c.onBlur(p);
+  }, m = (p) => {
+    if (p.nativeEvent.defaultPrevented)
+      return;
+    const Q = p.target.checked;
+    I(Q), h && h(p, Q);
+  };
+  let i = C;
+  c && typeof i > "u" && (i = c.disabled);
+  const se = b === "checkbox" || b === "radio", V = {
+    ...t,
+    checked: y,
+    disabled: i,
+    disableFocusRipple: k,
+    edge: v
+  }, K = de(V);
+  return /* @__PURE__ */ L(pe, {
+    component: "span",
+    className: j(K.root, d),
+    centerRipple: !0,
+    focusRipple: !k,
+    disabled: i,
+    tabIndex: null,
+    role: void 0,
+    onFocus: U,
+    onBlur: R,
+    ownerState: V,
+    ref: r,
+    ...E,
+    children: [/* @__PURE__ */ u(ue, {
+      autoFocus: s,
+      checked: a,
+      defaultChecked: n,
+      className: K.input,
+      disabled: i,
+      id: se ? F : void 0,
+      name: P,
+      onChange: m,
+      readOnly: M,
+      ref: O,
+      required: x,
+      ownerState: V,
+      tabIndex: N,
+      type: b,
+      ...b === "checkbox" && B === void 0 ? {} : {
+        value: B
+      },
+      ...$
+    }), y ? l : w]
+  });
+});
+process.env.NODE_ENV !== "production" && (re.propTypes = {
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   */
+  autoFocus: e.bool,
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: e.bool,
+  /**
+   * The icon to display when the component is checked.
+   */
+  checkedIcon: e.node.isRequired,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * @ignore
+   */
+  defaultChecked: e.bool,
+  /**
+   * If `true`, the component is disabled.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: e.bool,
+  /**
+   * If given, uses a negative margin to counteract the padding on one
+   * side (this is often helpful for aligning the left or right
+   * side of the icon with content above or below, without ruining the border
+   * size and shape).
+   * @default false
+   */
+  edge: e.oneOf(["end", "start", !1]),
+  /**
+   * The icon to display when the component is unchecked.
+   */
+  icon: e.node.isRequired,
+  /**
+   * The id of the `input` element.
+   */
+  id: e.string,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   */
+  inputProps: e.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: G,
+  /*
+   * @ignore
+   */
+  name: e.string,
+  /**
+   * @ignore
+   */
+  onBlur: e.func,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {object} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: e.func,
+  /**
+   * @ignore
+   */
+  onFocus: e.func,
+  /**
+   * It prevents the user from changing the value of the field
+   * (not from interacting with the field).
+   */
+  readOnly: e.bool,
+  /**
+   * If `true`, the `input` element is required.
+   */
+  required: e.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.object,
+  /**
+   * @ignore
+   */
+  tabIndex: e.oneOfType([e.number, e.string]),
+  /**
+   * The input component prop `type`.
+   */
+  type: e.string.isRequired,
+  /**
+   * The value of the component.
+   */
+  value: e.any
+});
+const be = J(/* @__PURE__ */ u("path", {
+  d: "M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"
+}), "CheckBoxOutlineBlank"), me = J(/* @__PURE__ */ u("path", {
+  d: "M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"
+}), "CheckBox"), fe = J(/* @__PURE__ */ u("path", {
+  d: "M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"
+}), "IndeterminateCheckBox");
+function he(o) {
+  return H("MuiCheckbox", o);
+}
+const D = A("MuiCheckbox", ["root", "checked", "disabled", "indeterminate", "colorPrimary", "colorSecondary", "sizeSmall", "sizeMedium"]), ye = (o) => {
+  const {
+    classes: t,
+    indeterminate: r,
+    color: s,
+    size: a
+  } = o, l = {
+    root: ["root", r && "indeterminate", `color${g(s)}`, `size${g(a)}`]
+  }, d = _(l, he, t);
+  return {
+    ...t,
+    // forward the disabled and checked classes to the SwitchBase
+    ...d
+  };
+}, ge = T(re, {
+  shouldForwardProp: (o) => ee(o) || o === "classes",
+  name: "MuiCheckbox",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.root, r.indeterminate && t.indeterminate, t[`size${g(r.size)}`], r.color !== "default" && t[`color${g(r.color)}`]];
+  }
+})(W(({
+  theme: o
+}) => ({
+  color: (o.vars || o).palette.text.secondary,
+  variants: [{
+    props: {
+      color: "default",
+      disableRipple: !1
+    },
+    style: {
+      "&:hover": {
+        backgroundColor: o.vars ? `rgba(${o.vars.palette.action.activeChannel} / ${o.vars.palette.action.hoverOpacity})` : X(o.palette.action.active, o.palette.action.hoverOpacity)
+      }
+    }
+  }, ...Object.entries(o.palette).filter(Y()).map(([t]) => ({
+    props: {
+      color: t,
+      disableRipple: !1
+    },
+    style: {
+      "&:hover": {
+        backgroundColor: o.vars ? `rgba(${o.vars.palette[t].mainChannel} / ${o.vars.palette.action.hoverOpacity})` : X(o.palette[t].main, o.palette.action.hoverOpacity)
+      }
+    }
+  })), ...Object.entries(o.palette).filter(Y()).map(([t]) => ({
+    props: {
+      color: t
+    },
+    style: {
+      [`&.${D.checked}, &.${D.indeterminate}`]: {
+        color: (o.vars || o).palette[t].main
+      },
+      [`&.${D.disabled}`]: {
+        color: (o.vars || o).palette.action.disabled
+      }
+    }
+  })), {
+    // 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"
+        }
+      }
+    }
+  }]
+}))), Ce = /* @__PURE__ */ u(me, {}), ke = /* @__PURE__ */ u(be, {}), ve = /* @__PURE__ */ u(fe, {}), Pe = /* @__PURE__ */ S.forwardRef(function(t, r) {
+  const s = oe({
+    props: t,
+    name: "MuiCheckbox"
+  }), {
+    checkedIcon: a = Ce,
+    color: l = "primary",
+    icon: d = ke,
+    indeterminate: n = !1,
+    indeterminateIcon: C = ve,
+    inputProps: k,
+    size: v = "medium",
+    disableRipple: w = !1,
+    className: F,
+    ...$
+  } = s, O = n ? C : d, P = n ? C : a, f = {
+    ...s,
+    disableRipple: w,
+    color: l,
+    indeterminate: n,
+    size: v
+  }, h = ye(f);
+  return /* @__PURE__ */ u(ge, {
+    type: "checkbox",
+    inputProps: {
+      "data-indeterminate": n,
+      ...k
+    },
+    icon: /* @__PURE__ */ S.cloneElement(O, {
+      fontSize: O.props.fontSize ?? v
+    }),
+    checkedIcon: /* @__PURE__ */ S.cloneElement(P, {
+      fontSize: P.props.fontSize ?? v
+    }),
+    ownerState: f,
+    ref: r,
+    className: j(h.root, F),
+    ...$,
+    classes: h
+  });
+});
+process.env.NODE_ENV !== "production" && (Pe.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: e.bool,
+  /**
+   * The icon to display when the component is checked.
+   * @default <CheckBoxIcon />
+   */
+  checkedIcon: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.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: e.oneOfType([e.oneOf(["default", "primary", "secondary", "error", "info", "success", "warning"]), e.string]),
+  /**
+   * The default checked state. Use when the component is not controlled.
+   */
+  defaultChecked: e.bool,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   * @default false
+   */
+  disableRipple: e.bool,
+  /**
+   * The icon to display when the component is unchecked.
+   * @default <CheckBoxOutlineBlankIcon />
+   */
+  icon: e.node,
+  /**
+   * The id of the `input` element.
+   */
+  id: e.string,
+  /**
+   * If `true`, the component appears indeterminate.
+   * This does not set the native input element to indeterminate due
+   * to inconsistent behavior across browsers.
+   * However, we set a `data-indeterminate` attribute on the `input`.
+   * @default false
+   */
+  indeterminate: e.bool,
+  /**
+   * The icon to display when the component is indeterminate.
+   * @default <IndeterminateCheckBoxIcon />
+   */
+  indeterminateIcon: e.node,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   */
+  inputProps: e.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: G,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: e.func,
+  /**
+   * If `true`, the `input` element is required.
+   * @default false
+   */
+  required: e.bool,
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense checkbox styling.
+   * @default 'medium'
+   */
+  size: e.oneOfType([e.oneOf(["medium", "small"]), e.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The value of the component. The DOM API casts this to a string.
+   * The browser uses "on" as the default value.
+   */
+  value: e.any
+});
+function xe(o) {
+  return H("MuiFormControlLabel", o);
+}
+const z = A("MuiFormControlLabel", ["root", "labelPlacementStart", "labelPlacementTop", "labelPlacementBottom", "disabled", "label", "error", "required", "asterisk"]), Re = (o) => {
+  const {
+    classes: t,
+    disabled: r,
+    labelPlacement: s,
+    error: a,
+    required: l
+  } = o, d = {
+    root: ["root", r && "disabled", `labelPlacement${g(s)}`, a && "error", l && "required"],
+    label: ["label", r && "disabled"],
+    asterisk: ["asterisk", a && "error"]
+  };
+  return _(d, xe, t);
+}, Se = T("label", {
+  name: "MuiFormControlLabel",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [{
+      [`& .${z.label}`]: t.label
+    }, t.root, t[`labelPlacement${g(r.labelPlacement)}`]];
+  }
+})(W(({
+  theme: o
+}) => ({
+  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
+  [`&.${z.disabled}`]: {
+    cursor: "default"
+  },
+  [`& .${z.label}`]: {
+    [`&.${z.disabled}`]: {
+      color: (o.vars || o).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: t
+    }) => t === "start" || t === "top" || t === "bottom",
+    style: {
+      marginLeft: 16
+      // used for row presentation of radio/checkbox
+    }
+  }]
+}))), we = T("span", {
+  name: "MuiFormControlLabel",
+  slot: "Asterisk",
+  overridesResolver: (o, t) => t.asterisk
+})(W(({
+  theme: o
+}) => ({
+  [`&.${z.error}`]: {
+    color: (o.vars || o).palette.error.main
+  }
+}))), Fe = /* @__PURE__ */ S.forwardRef(function(t, r) {
+  const s = oe({
+    props: t,
+    name: "MuiFormControlLabel"
+  }), {
+    checked: a,
+    className: l,
+    componentsProps: d = {},
+    control: n,
+    disabled: C,
+    disableTypography: k,
+    inputRef: v,
+    label: w,
+    labelPlacement: F = "end",
+    name: $,
+    onChange: O,
+    required: P,
+    slots: f = {},
+    slotProps: h = {},
+    value: q,
+    ...M
+  } = s, x = te(), N = C ?? n.props.disabled ?? (x == null ? void 0 : x.disabled), b = P ?? n.props.required, B = {
+    disabled: N,
+    required: b
+  };
+  ["checked", "name", "onChange", "value", "inputRef"].forEach((i) => {
+    typeof n.props[i] > "u" && typeof s[i] < "u" && (B[i] = s[i]);
+  });
+  const E = ae({
+    props: s,
+    muiFormControl: x,
+    states: ["error"]
+  }), y = {
+    ...s,
+    disabled: N,
+    labelPlacement: F,
+    required: b,
+    error: E.error
+  }, I = Re(y), c = {
+    slots: f,
+    slotProps: {
+      ...d,
+      ...h
+    }
+  }, [U, R] = ce("typography", {
+    elementType: Z,
+    externalForwardedProps: c,
+    ownerState: y
+  });
+  let m = w;
+  return m != null && m.type !== Z && !k && (m = /* @__PURE__ */ u(U, {
+    component: "span",
+    ...R,
+    className: j(I.label, R == null ? void 0 : R.className),
+    children: m
+  })), /* @__PURE__ */ L(Se, {
+    className: j(I.root, l),
+    ownerState: y,
+    ref: r,
+    ...M,
+    children: [/* @__PURE__ */ S.cloneElement(n, B), b ? /* @__PURE__ */ L("div", {
+      children: [m, /* @__PURE__ */ L(we, {
+        ownerState: y,
+        "aria-hidden": !0,
+        className: I.asterisk,
+        children: [" ", "*"]
+      })]
+    }) : m]
+  });
+});
+process.env.NODE_ENV !== "production" && (Fe.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: e.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  componentsProps: e.shape({
+    typography: e.object
+  }),
+  /**
+   * A control element. For instance, it can be a `Radio`, a `Switch` or a `Checkbox`.
+   */
+  control: e.element.isRequired,
+  /**
+   * If `true`, the control is disabled.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the label is rendered as it is passed without an additional typography node.
+   */
+  disableTypography: e.bool,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: G,
+  /**
+   * A text or an element to be used in an enclosing label element.
+   */
+  label: e.node,
+  /**
+   * The position of the label.
+   * @default 'end'
+   */
+  labelPlacement: e.oneOf(["bottom", "end", "start", "top"]),
+  /**
+   * @ignore
+   */
+  name: e.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: e.func,
+  /**
+   * If `true`, the label will indicate that the `input` is required.
+   */
+  required: e.bool,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    typography: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: e.shape({
+    typography: e.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The value of the component.
+   */
+  value: e.any
+});
+export {
+  Pe as C,
+  Fe as F
+};