impact-ui 3.7.34-alpha.2 → 3.7.34-alpha.3

package/dist/node_modules/@mui/material/FormControl/FormControl.js

@@ -0,0 +1,259 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from "react";
+import PropTypes from "../../../prop-types/index.js";
+import { clsx } from "../../../clsx/dist/clsx.js";
+import styled from "../styles/styled.js";
+import { isAdornedStart, isFilled } from "../InputBase/utils.js";
+import FormControlContext from "./FormControlContext.js";
+import { getFormControlUtilityClasses } from "./formControlClasses.js";
+import { jsx } from "react/jsx-runtime";
+import { useDefaultProps } from "../DefaultPropsProvider/DefaultPropsProvider.js";
+import isMuiElement from "../node_modules/@mui/utils/esm/isMuiElement/isMuiElement.js";
+import capitalize from "../node_modules/@mui/utils/esm/capitalize/capitalize.js";
+import composeClasses from "../node_modules/@mui/utils/esm/composeClasses/composeClasses.js";
+const _excluded = ["children", "className", "color", "component", "disabled", "error", "focused", "fullWidth", "hiddenLabel", "margin", "required", "size", "variant"];
+const useUtilityClasses = (ownerState) => {
+  const {
+    classes,
+    margin,
+    fullWidth
+  } = ownerState;
+  const slots = {
+    root: ["root", margin !== "none" && `margin${capitalize(margin)}`, fullWidth && "fullWidth"]
+  };
+  return composeClasses(slots, getFormControlUtilityClasses, classes);
+};
+const FormControlRoot = styled("div", {
+  name: "MuiFormControl",
+  slot: "Root",
+  overridesResolver: ({
+    ownerState
+  }, styles) => {
+    return _extends({}, styles.root, styles[`margin${capitalize(ownerState.margin)}`], ownerState.fullWidth && styles.fullWidth);
+  }
+})(({
+  ownerState
+}) => _extends({
+  display: "inline-flex",
+  flexDirection: "column",
+  position: "relative",
+  // Reset fieldset default style.
+  minWidth: 0,
+  padding: 0,
+  margin: 0,
+  border: 0,
+  verticalAlign: "top"
+}, ownerState.margin === "normal" && {
+  marginTop: 16,
+  marginBottom: 8
+}, ownerState.margin === "dense" && {
+  marginTop: 8,
+  marginBottom: 4
+}, ownerState.fullWidth && {
+  width: "100%"
+}));
+const FormControl = /* @__PURE__ */ React.forwardRef(function FormControl2(inProps, ref) {
+  const props = useDefaultProps({
+    props: inProps,
+    name: "MuiFormControl"
+  });
+  const {
+    children,
+    className,
+    color = "primary",
+    component = "div",
+    disabled = false,
+    error = false,
+    focused: visuallyFocused,
+    fullWidth = false,
+    hiddenLabel = false,
+    margin = "none",
+    required = false,
+    size = "medium",
+    variant = "outlined"
+  } = props, other = _objectWithoutPropertiesLoose(props, _excluded);
+  const ownerState = _extends({}, props, {
+    color,
+    component,
+    disabled,
+    error,
+    fullWidth,
+    hiddenLabel,
+    margin,
+    required,
+    size,
+    variant
+  });
+  const classes = useUtilityClasses(ownerState);
+  const [adornedStart, setAdornedStart] = React.useState(() => {
+    let initialAdornedStart = false;
+    if (children) {
+      React.Children.forEach(children, (child) => {
+        if (!isMuiElement(child, ["Input", "Select"])) {
+          return;
+        }
+        const input = isMuiElement(child, ["Select"]) ? child.props.input : child;
+        if (input && isAdornedStart(input.props)) {
+          initialAdornedStart = true;
+        }
+      });
+    }
+    return initialAdornedStart;
+  });
+  const [filled, setFilled] = React.useState(() => {
+    let initialFilled = false;
+    if (children) {
+      React.Children.forEach(children, (child) => {
+        if (!isMuiElement(child, ["Input", "Select"])) {
+          return;
+        }
+        if (isFilled(child.props, true) || isFilled(child.props.inputProps, true)) {
+          initialFilled = true;
+        }
+      });
+    }
+    return initialFilled;
+  });
+  const [focusedState, setFocused] = React.useState(false);
+  if (disabled && focusedState) {
+    setFocused(false);
+  }
+  const focused = visuallyFocused !== void 0 && !disabled ? visuallyFocused : focusedState;
+  let registerEffect;
+  if (process.env.NODE_ENV !== "production") {
+    const registeredInput = React.useRef(false);
+    registerEffect = () => {
+      if (registeredInput.current) {
+        console.error(["MUI: There are multiple `InputBase` components inside a FormControl.", "This creates visual inconsistencies, only use one `InputBase`."].join("\n"));
+      }
+      registeredInput.current = true;
+      return () => {
+        registeredInput.current = false;
+      };
+    };
+  }
+  const childContext = React.useMemo(() => {
+    return {
+      adornedStart,
+      setAdornedStart,
+      color,
+      disabled,
+      error,
+      filled,
+      focused,
+      fullWidth,
+      hiddenLabel,
+      size,
+      onBlur: () => {
+        setFocused(false);
+      },
+      onEmpty: () => {
+        setFilled(false);
+      },
+      onFilled: () => {
+        setFilled(true);
+      },
+      onFocus: () => {
+        setFocused(true);
+      },
+      registerEffect,
+      required,
+      variant
+    };
+  }, [adornedStart, color, disabled, error, filled, focused, fullWidth, hiddenLabel, registerEffect, required, size, variant]);
+  return /* @__PURE__ */ jsx(FormControlContext.Provider, {
+    value: childContext,
+    children: /* @__PURE__ */ jsx(FormControlRoot, _extends({
+      as: component,
+      ownerState,
+      className: clsx(classes.root, className),
+      ref
+    }, other, {
+      children
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" ? FormControl.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: PropTypes.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * @ignore
+   */
+  className: PropTypes.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: PropTypes.oneOfType([PropTypes.oneOf(["primary", "secondary", "error", "info", "success", "warning"]), PropTypes.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: PropTypes.elementType,
+  /**
+   * If `true`, the label, input and helper text should be displayed in a disabled state.
+   * @default false
+   */
+  disabled: PropTypes.bool,
+  /**
+   * If `true`, the label is displayed in an error state.
+   * @default false
+   */
+  error: PropTypes.bool,
+  /**
+   * If `true`, the component is displayed in focused state.
+   */
+  focused: PropTypes.bool,
+  /**
+   * If `true`, the component will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: PropTypes.bool,
+  /**
+   * If `true`, the label is hidden.
+   * This is used to increase density for a `FilledInput`.
+   * Be sure to add `aria-label` to the `input` element.
+   * @default false
+   */
+  hiddenLabel: PropTypes.bool,
+  /**
+   * If `dense` or `normal`, will adjust vertical spacing of this and contained components.
+   * @default 'none'
+   */
+  margin: PropTypes.oneOf(["dense", "none", "normal"]),
+  /**
+   * If `true`, the label will indicate that the `input` is required.
+   * @default false
+   */
+  required: PropTypes.bool,
+  /**
+   * The size of the component.
+   * @default 'medium'
+   */
+  size: PropTypes.oneOfType([PropTypes.oneOf(["medium", "small"]), PropTypes.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * The variant to use.
+   * @default 'outlined'
+   */
+  variant: PropTypes.oneOf(["filled", "outlined", "standard"])
+} : void 0;
+export {
+  FormControl as default
+};

package/dist/node_modules/@mui/material/FormControl/FormControlContext.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const FormControlContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") {
+  FormControlContext.displayName = "FormControlContext";
+}
+export {
+  FormControlContext as default
+};

package/dist/node_modules/@mui/material/FormControl/formControlClasses.js

@@ -0,0 +1,9 @@
+import generateUtilityClass from "../node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js";
+import generateUtilityClasses from "../node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.js";
+function getFormControlUtilityClasses(slot) {
+  return generateUtilityClass("MuiFormControl", slot);
+}
+generateUtilityClasses("MuiFormControl", ["root", "marginNone", "marginNormal", "marginDense", "fullWidth", "disabled"]);
+export {
+  getFormControlUtilityClasses
+};

package/dist/node_modules/@mui/material/FormControl/formControlState.js

@@ -0,0 +1,18 @@
+function formControlState({
+  props,
+  states,
+  muiFormControl
+}) {
+  return states.reduce((acc, state) => {
+    acc[state] = props[state];
+    if (muiFormControl) {
+      if (typeof props[state] === "undefined") {
+        acc[state] = muiFormControl[state];
+      }
+    }
+    return acc;
+  }, {});
+}
+export {
+  formControlState as default
+};

package/dist/node_modules/@mui/material/FormControl/useFormControl.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+import FormControlContext from "./FormControlContext.js";
+function useFormControl() {
+  return React.useContext(FormControlContext);
+}
+export {
+  useFormControl as default
+};

package/dist/node_modules/@mui/material/FormControlLabel/FormControlLabel.js

@@ -0,0 +1,239 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from "react";
+import PropTypes from "../../../prop-types/index.js";
+import { clsx } from "../../../clsx/dist/clsx.js";
+import styled from "../styles/styled.js";
+import formControlLabelClasses, { getFormControlLabelUtilityClasses } from "./formControlLabelClasses.js";
+import formControlState from "../FormControl/formControlState.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useDefaultProps } from "../DefaultPropsProvider/DefaultPropsProvider.js";
+import useFormControl from "../FormControl/useFormControl.js";
+import Typography from "../Typography/Typography.js";
+import Stack from "../Stack/Stack.js";
+import capitalize from "../node_modules/@mui/utils/esm/capitalize/capitalize.js";
+import composeClasses from "../node_modules/@mui/utils/esm/composeClasses/composeClasses.js";
+import refType from "../node_modules/@mui/utils/esm/refType/refType.js";
+const _excluded = ["checked", "className", "componentsProps", "control", "disabled", "disableTypography", "inputRef", "label", "labelPlacement", "name", "onChange", "required", "slotProps", "value"];
+const useUtilityClasses = (ownerState) => {
+  const {
+    classes,
+    disabled,
+    labelPlacement,
+    error,
+    required
+  } = ownerState;
+  const slots = {
+    root: ["root", disabled && "disabled", `labelPlacement${capitalize(labelPlacement)}`, error && "error", required && "required"],
+    label: ["label", disabled && "disabled"],
+    asterisk: ["asterisk", error && "error"]
+  };
+  return composeClasses(slots, getFormControlLabelUtilityClasses, classes);
+};
+const FormControlLabelRoot = styled("label", {
+  name: "MuiFormControlLabel",
+  slot: "Root",
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [{
+      [`& .${formControlLabelClasses.label}`]: styles.label
+    }, styles.root, styles[`labelPlacement${capitalize(ownerState.labelPlacement)}`]];
+  }
+})(({
+  theme,
+  ownerState
+}) => _extends({
+  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
+  [`&.${formControlLabelClasses.disabled}`]: {
+    cursor: "default"
+  }
+}, ownerState.labelPlacement === "start" && {
+  flexDirection: "row-reverse",
+  marginLeft: 16,
+  // used for row presentation of radio/checkbox
+  marginRight: -11
+}, ownerState.labelPlacement === "top" && {
+  flexDirection: "column-reverse",
+  marginLeft: 16
+}, ownerState.labelPlacement === "bottom" && {
+  flexDirection: "column",
+  marginLeft: 16
+}, {
+  [`& .${formControlLabelClasses.label}`]: {
+    [`&.${formControlLabelClasses.disabled}`]: {
+      color: (theme.vars || theme).palette.text.disabled
+    }
+  }
+}));
+const AsteriskComponent = styled("span", {
+  name: "MuiFormControlLabel",
+  slot: "Asterisk",
+  overridesResolver: (props, styles) => styles.asterisk
+})(({
+  theme
+}) => ({
+  [`&.${formControlLabelClasses.error}`]: {
+    color: (theme.vars || theme).palette.error.main
+  }
+}));
+const FormControlLabel = /* @__PURE__ */ React.forwardRef(function FormControlLabel2(inProps, ref) {
+  var _ref, _slotProps$typography;
+  const props = useDefaultProps({
+    props: inProps,
+    name: "MuiFormControlLabel"
+  });
+  const {
+    className,
+    componentsProps = {},
+    control,
+    disabled: disabledProp,
+    disableTypography,
+    label: labelProp,
+    labelPlacement = "end",
+    required: requiredProp,
+    slotProps = {}
+  } = props, other = _objectWithoutPropertiesLoose(props, _excluded);
+  const muiFormControl = useFormControl();
+  const disabled = (_ref = disabledProp != null ? disabledProp : control.props.disabled) != null ? _ref : muiFormControl == null ? void 0 : muiFormControl.disabled;
+  const required = requiredProp != null ? requiredProp : control.props.required;
+  const controlProps = {
+    disabled,
+    required
+  };
+  ["checked", "name", "onChange", "value", "inputRef"].forEach((key) => {
+    if (typeof control.props[key] === "undefined" && typeof props[key] !== "undefined") {
+      controlProps[key] = props[key];
+    }
+  });
+  const fcs = formControlState({
+    props,
+    muiFormControl,
+    states: ["error"]
+  });
+  const ownerState = _extends({}, props, {
+    disabled,
+    labelPlacement,
+    required,
+    error: fcs.error
+  });
+  const classes = useUtilityClasses(ownerState);
+  const typographySlotProps = (_slotProps$typography = slotProps.typography) != null ? _slotProps$typography : componentsProps.typography;
+  let label = labelProp;
+  if (label != null && label.type !== Typography && !disableTypography) {
+    label = /* @__PURE__ */ jsx(Typography, _extends({
+      component: "span"
+    }, typographySlotProps, {
+      className: clsx(classes.label, typographySlotProps == null ? void 0 : typographySlotProps.className),
+      children: label
+    }));
+  }
+  return /* @__PURE__ */ jsxs(FormControlLabelRoot, _extends({
+    className: clsx(classes.root, className),
+    ownerState,
+    ref
+  }, other, {
+    children: [/* @__PURE__ */ React.cloneElement(control, controlProps), required ? /* @__PURE__ */ jsxs(Stack, {
+      display: "block",
+      children: [label, /* @__PURE__ */ jsxs(AsteriskComponent, {
+        ownerState,
+        "aria-hidden": true,
+        className: classes.asterisk,
+        children: [" ", "*"]
+      })]
+    }) : label]
+  }));
+});
+process.env.NODE_ENV !== "production" ? FormControlLabel.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: PropTypes.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  componentsProps: PropTypes.shape({
+    typography: PropTypes.object
+  }),
+  /**
+   * A control element. For instance, it can be a `Radio`, a `Switch` or a `Checkbox`.
+   */
+  control: PropTypes.element.isRequired,
+  /**
+   * If `true`, the control is disabled.
+   */
+  disabled: PropTypes.bool,
+  /**
+   * If `true`, the label is rendered as it is passed without an additional typography node.
+   */
+  disableTypography: PropTypes.bool,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: refType,
+  /**
+   * A text or an element to be used in an enclosing label element.
+   */
+  label: PropTypes.node,
+  /**
+   * The position of the label.
+   * @default 'end'
+   */
+  labelPlacement: PropTypes.oneOf(["bottom", "end", "start", "top"]),
+  /**
+   * @ignore
+   */
+  name: PropTypes.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: PropTypes.func,
+  /**
+   * If `true`, the label will indicate that the `input` is required.
+   */
+  required: PropTypes.bool,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: PropTypes.shape({
+    typography: PropTypes.object
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * The value of the component.
+   */
+  value: PropTypes.any
+} : void 0;
+export {
+  FormControlLabelRoot,
+  FormControlLabel as default
+};

package/dist/node_modules/@mui/material/FormControlLabel/formControlLabelClasses.js

@@ -0,0 +1,10 @@
+import generateUtilityClass from "../node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js";
+import generateUtilityClasses from "../node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.js";
+function getFormControlLabelUtilityClasses(slot) {
+  return generateUtilityClass("MuiFormControlLabel", slot);
+}
+const formControlLabelClasses = generateUtilityClasses("MuiFormControlLabel", ["root", "labelPlacementStart", "labelPlacementTop", "labelPlacementBottom", "disabled", "label", "error", "required", "asterisk"]);
+export {
+  formControlLabelClasses as default,
+  getFormControlLabelUtilityClasses
+};

package/dist/node_modules/@mui/material/FormGroup/FormGroup.js

@@ -0,0 +1,98 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from "react";
+import PropTypes from "../../../prop-types/index.js";
+import { clsx } from "../../../clsx/dist/clsx.js";
+import styled from "../styles/styled.js";
+import { getFormGroupUtilityClass } from "./formGroupClasses.js";
+import useFormControl from "../FormControl/useFormControl.js";
+import formControlState from "../FormControl/formControlState.js";
+import { jsx } from "react/jsx-runtime";
+import { useDefaultProps } from "../DefaultPropsProvider/DefaultPropsProvider.js";
+import composeClasses from "../node_modules/@mui/utils/esm/composeClasses/composeClasses.js";
+const _excluded = ["className", "row"];
+const useUtilityClasses = (ownerState) => {
+  const {
+    classes,
+    row,
+    error
+  } = ownerState;
+  const slots = {
+    root: ["root", row && "row", error && "error"]
+  };
+  return composeClasses(slots, getFormGroupUtilityClass, classes);
+};
+const FormGroupRoot = styled("div", {
+  name: "MuiFormGroup",
+  slot: "Root",
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.root, ownerState.row && styles.row];
+  }
+})(({
+  ownerState
+}) => _extends({
+  display: "flex",
+  flexDirection: "column",
+  flexWrap: "wrap"
+}, ownerState.row && {
+  flexDirection: "row"
+}));
+const FormGroup = /* @__PURE__ */ React.forwardRef(function FormGroup2(inProps, ref) {
+  const props = useDefaultProps({
+    props: inProps,
+    name: "MuiFormGroup"
+  });
+  const {
+    className,
+    row = false
+  } = props, other = _objectWithoutPropertiesLoose(props, _excluded);
+  const muiFormControl = useFormControl();
+  const fcs = formControlState({
+    props,
+    muiFormControl,
+    states: ["error"]
+  });
+  const ownerState = _extends({}, props, {
+    row,
+    error: fcs.error
+  });
+  const classes = useUtilityClasses(ownerState);
+  return /* @__PURE__ */ jsx(FormGroupRoot, _extends({
+    className: clsx(classes.root, className),
+    ownerState,
+    ref
+  }, other));
+});
+process.env.NODE_ENV !== "production" ? FormGroup.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: PropTypes.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * Display group of elements in a compact row.
+   * @default false
+   */
+  row: PropTypes.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
+} : void 0;
+export {
+  FormGroup as default
+};

package/dist/node_modules/@mui/material/FormGroup/formGroupClasses.js

@@ -0,0 +1,9 @@
+import generateUtilityClass from "../node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js";
+import generateUtilityClasses from "../node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.js";
+function getFormGroupUtilityClass(slot) {
+  return generateUtilityClass("MuiFormGroup", slot);
+}
+generateUtilityClasses("MuiFormGroup", ["root", "row", "error"]);
+export {
+  getFormGroupUtilityClass
+};