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

package/dist/node_modules/@mui/system/esm/createStyled.js

@@ -0,0 +1,231 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import styled, { internal_processStyles, internal_serializeStyles } from "../../styled-engine/index.js";
+import capitalize from "../node_modules/@mui/utils/esm/capitalize/capitalize.js";
+import getDisplayName from "../node_modules/@mui/utils/esm/getDisplayName/getDisplayName.js";
+import createTheme from "./createTheme/createTheme.js";
+import styleFunctionSx from "./styleFunctionSx/styleFunctionSx.js";
+import { isPlainObject } from "../node_modules/@mui/utils/esm/deepmerge/deepmerge.js";
+const _excluded = ["ownerState"], _excluded2 = ["variants"], _excluded3 = ["name", "slot", "skipVariantsResolver", "skipSx", "overridesResolver"];
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}
+function isStringTag(tag) {
+  return typeof tag === "string" && // 96 is one less than the char code
+  // for "a" so this is checking that
+  // it's a lowercase character
+  tag.charCodeAt(0) > 96;
+}
+function shouldForwardProp(prop) {
+  return prop !== "ownerState" && prop !== "theme" && prop !== "sx" && prop !== "as";
+}
+function shallowLayer(serialized, layerName) {
+  if (layerName && serialized && typeof serialized === "object" && serialized.styles && !serialized.styles.startsWith("@layer")) {
+    serialized.styles = `@layer ${layerName}{${String(serialized.styles)}}`;
+  }
+  return serialized;
+}
+const systemDefaultTheme = createTheme();
+const lowercaseFirstLetter = (string) => {
+  if (!string) {
+    return string;
+  }
+  return string.charAt(0).toLowerCase() + string.slice(1);
+};
+function resolveTheme({
+  defaultTheme,
+  theme,
+  themeId
+}) {
+  return isEmpty(theme) ? defaultTheme : theme[themeId] || theme;
+}
+function defaultOverridesResolver(slot) {
+  if (!slot) {
+    return null;
+  }
+  return (props, styles) => styles[slot];
+}
+function processStyleArg(callableStyle, _ref, layerName) {
+  let {
+    ownerState
+  } = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  const resolvedStylesArg = typeof callableStyle === "function" ? callableStyle(_extends({
+    ownerState
+  }, props)) : callableStyle;
+  if (Array.isArray(resolvedStylesArg)) {
+    return resolvedStylesArg.flatMap((resolvedStyle) => processStyleArg(resolvedStyle, _extends({
+      ownerState
+    }, props), layerName));
+  }
+  if (!!resolvedStylesArg && typeof resolvedStylesArg === "object" && Array.isArray(resolvedStylesArg.variants)) {
+    const {
+      variants = []
+    } = resolvedStylesArg, otherStyles = _objectWithoutPropertiesLoose(resolvedStylesArg, _excluded2);
+    let result = otherStyles;
+    variants.forEach((variant) => {
+      let isMatch = true;
+      if (typeof variant.props === "function") {
+        isMatch = variant.props(_extends({
+          ownerState
+        }, props, ownerState));
+      } else {
+        Object.keys(variant.props).forEach((key) => {
+          if ((ownerState == null ? void 0 : ownerState[key]) !== variant.props[key] && props[key] !== variant.props[key]) {
+            isMatch = false;
+          }
+        });
+      }
+      if (isMatch) {
+        if (!Array.isArray(result)) {
+          result = [result];
+        }
+        const variantStyle = typeof variant.style === "function" ? variant.style(_extends({
+          ownerState
+        }, props, ownerState)) : variant.style;
+        result.push(layerName ? shallowLayer(internal_serializeStyles(variantStyle), layerName) : variantStyle);
+      }
+    });
+    return result;
+  }
+  return layerName ? shallowLayer(internal_serializeStyles(resolvedStylesArg), layerName) : resolvedStylesArg;
+}
+function createStyled(input = {}) {
+  const {
+    themeId,
+    defaultTheme = systemDefaultTheme,
+    rootShouldForwardProp = shouldForwardProp,
+    slotShouldForwardProp = shouldForwardProp
+  } = input;
+  const systemSx = (props) => {
+    return styleFunctionSx(_extends({}, props, {
+      theme: resolveTheme(_extends({}, props, {
+        defaultTheme,
+        themeId
+      }))
+    }));
+  };
+  systemSx.__mui_systemSx = true;
+  return (tag, inputOptions = {}) => {
+    internal_processStyles(tag, (styles) => styles.filter((style) => !(style != null && style.__mui_systemSx)));
+    const {
+      name: componentName,
+      slot: componentSlot,
+      skipVariantsResolver: inputSkipVariantsResolver,
+      skipSx: inputSkipSx,
+      // TODO v6: remove `lowercaseFirstLetter()` in the next major release
+      // For more details: https://github.com/mui/material-ui/pull/37908
+      overridesResolver = defaultOverridesResolver(lowercaseFirstLetter(componentSlot))
+    } = inputOptions, options = _objectWithoutPropertiesLoose(inputOptions, _excluded3);
+    const layerName = componentName && componentName.startsWith("Mui") || !!componentSlot ? "components" : "custom";
+    const skipVariantsResolver = inputSkipVariantsResolver !== void 0 ? inputSkipVariantsResolver : (
+      // TODO v6: remove `Root` in the next major release
+      // For more details: https://github.com/mui/material-ui/pull/37908
+      componentSlot && componentSlot !== "Root" && componentSlot !== "root" || false
+    );
+    const skipSx = inputSkipSx || false;
+    let label;
+    if (process.env.NODE_ENV !== "production") {
+      if (componentName) {
+        label = `${componentName}-${lowercaseFirstLetter(componentSlot || "Root")}`;
+      }
+    }
+    let shouldForwardPropOption = shouldForwardProp;
+    if (componentSlot === "Root" || componentSlot === "root") {
+      shouldForwardPropOption = rootShouldForwardProp;
+    } else if (componentSlot) {
+      shouldForwardPropOption = slotShouldForwardProp;
+    } else if (isStringTag(tag)) {
+      shouldForwardPropOption = void 0;
+    }
+    const defaultStyledResolver = styled(tag, _extends({
+      shouldForwardProp: shouldForwardPropOption,
+      label
+    }, options));
+    const transformStyleArg = (stylesArg) => {
+      if (typeof stylesArg === "function" && stylesArg.__emotion_real !== stylesArg || isPlainObject(stylesArg)) {
+        return (props) => {
+          const theme = resolveTheme({
+            theme: props.theme,
+            defaultTheme,
+            themeId
+          });
+          return processStyleArg(stylesArg, _extends({}, props, {
+            theme
+          }), theme.modularCssLayers ? layerName : void 0);
+        };
+      }
+      return stylesArg;
+    };
+    const muiStyledResolver = (styleArg, ...expressions) => {
+      let transformedStyleArg = transformStyleArg(styleArg);
+      const expressionsWithDefaultTheme = expressions ? expressions.map(transformStyleArg) : [];
+      if (componentName && overridesResolver) {
+        expressionsWithDefaultTheme.push((props) => {
+          const theme = resolveTheme(_extends({}, props, {
+            defaultTheme,
+            themeId
+          }));
+          if (!theme.components || !theme.components[componentName] || !theme.components[componentName].styleOverrides) {
+            return null;
+          }
+          const styleOverrides = theme.components[componentName].styleOverrides;
+          const resolvedStyleOverrides = {};
+          Object.entries(styleOverrides).forEach(([slotKey, slotStyle]) => {
+            resolvedStyleOverrides[slotKey] = processStyleArg(slotStyle, _extends({}, props, {
+              theme
+            }), theme.modularCssLayers ? "theme" : void 0);
+          });
+          return overridesResolver(props, resolvedStyleOverrides);
+        });
+      }
+      if (componentName && !skipVariantsResolver) {
+        expressionsWithDefaultTheme.push((props) => {
+          var _theme$components;
+          const theme = resolveTheme(_extends({}, props, {
+            defaultTheme,
+            themeId
+          }));
+          const themeVariants = theme == null || (_theme$components = theme.components) == null || (_theme$components = _theme$components[componentName]) == null ? void 0 : _theme$components.variants;
+          return processStyleArg({
+            variants: themeVariants
+          }, _extends({}, props, {
+            theme
+          }), theme.modularCssLayers ? "theme" : void 0);
+        });
+      }
+      if (!skipSx) {
+        expressionsWithDefaultTheme.push(systemSx);
+      }
+      const numOfCustomFnsApplied = expressionsWithDefaultTheme.length - expressions.length;
+      if (Array.isArray(styleArg) && numOfCustomFnsApplied > 0) {
+        const placeholders = new Array(numOfCustomFnsApplied).fill("");
+        transformedStyleArg = [...styleArg, ...placeholders];
+        transformedStyleArg.raw = [...styleArg.raw, ...placeholders];
+      }
+      const Component = defaultStyledResolver(transformedStyleArg, ...expressionsWithDefaultTheme);
+      if (process.env.NODE_ENV !== "production") {
+        let displayName;
+        if (componentName) {
+          displayName = `${componentName}${capitalize(componentSlot || "")}`;
+        }
+        if (displayName === void 0) {
+          displayName = `Styled(${getDisplayName(tag)})`;
+        }
+        Component.displayName = displayName;
+      }
+      if (tag.muiName) {
+        Component.muiName = tag.muiName;
+      }
+      return Component;
+    };
+    if (defaultStyledResolver.withConfig) {
+      muiStyledResolver.withConfig = defaultStyledResolver.withConfig;
+    }
+    return muiStyledResolver;
+  };
+}
+export {
+  createStyled as default,
+  shouldForwardProp,
+  systemDefaultTheme
+};

package/dist/node_modules/@mui/system/esm/createTheme/applyStyles.js

@@ -0,0 +1,16 @@
+function applyStyles(key, styles) {
+  const theme = this;
+  if (theme.vars && typeof theme.getColorSchemeSelector === "function") {
+    const selector = theme.getColorSchemeSelector(key).replace(/(\[[^\]]+\])/, "*:where($1)");
+    return {
+      [selector]: styles
+    };
+  }
+  if (theme.palette.mode === key) {
+    return styles;
+  }
+  return {};
+}
+export {
+  applyStyles as default
+};

package/dist/node_modules/@mui/system/esm/createTheme/createBreakpoints.js

@@ -0,0 +1,78 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["values", "unit", "step"];
+const sortBreakpointsValues = (values) => {
+  const breakpointsAsArray = Object.keys(values).map((key) => ({
+    key,
+    val: values[key]
+  })) || [];
+  breakpointsAsArray.sort((breakpoint1, breakpoint2) => breakpoint1.val - breakpoint2.val);
+  return breakpointsAsArray.reduce((acc, obj) => {
+    return _extends({}, acc, {
+      [obj.key]: obj.val
+    });
+  }, {});
+};
+function createBreakpoints(breakpoints) {
+  const {
+    // The breakpoint **start** at this value.
+    // For instance with the first breakpoint xs: [xs, sm).
+    values = {
+      xs: 0,
+      // phone
+      sm: 600,
+      // tablet
+      md: 900,
+      // small laptop
+      lg: 1200,
+      // desktop
+      xl: 1536
+      // large screen
+    },
+    unit = "px",
+    step = 5
+  } = breakpoints, other = _objectWithoutPropertiesLoose(breakpoints, _excluded);
+  const sortedValues = sortBreakpointsValues(values);
+  const keys = Object.keys(sortedValues);
+  function up(key) {
+    const value = typeof values[key] === "number" ? values[key] : key;
+    return `@media (min-width:${value}${unit})`;
+  }
+  function down(key) {
+    const value = typeof values[key] === "number" ? values[key] : key;
+    return `@media (max-width:${value - step / 100}${unit})`;
+  }
+  function between(start, end) {
+    const endIndex = keys.indexOf(end);
+    return `@media (min-width:${typeof values[start] === "number" ? values[start] : start}${unit}) and (max-width:${(endIndex !== -1 && typeof values[keys[endIndex]] === "number" ? values[keys[endIndex]] : end) - step / 100}${unit})`;
+  }
+  function only(key) {
+    if (keys.indexOf(key) + 1 < keys.length) {
+      return between(key, keys[keys.indexOf(key) + 1]);
+    }
+    return up(key);
+  }
+  function not(key) {
+    const keyIndex = keys.indexOf(key);
+    if (keyIndex === 0) {
+      return up(keys[1]);
+    }
+    if (keyIndex === keys.length - 1) {
+      return down(keys[keyIndex]);
+    }
+    return between(key, keys[keys.indexOf(key) + 1]).replace("@media", "@media not all and");
+  }
+  return _extends({
+    keys,
+    values: sortedValues,
+    up,
+    down,
+    between,
+    only,
+    not,
+    unit
+  }, other);
+}
+export {
+  createBreakpoints as default
+};

package/dist/node_modules/@mui/system/esm/createTheme/createSpacing.js

@@ -0,0 +1,26 @@
+import { createUnarySpacing } from "../spacing.js";
+function createSpacing(spacingInput = 8) {
+  if (spacingInput.mui) {
+    return spacingInput;
+  }
+  const transform = createUnarySpacing({
+    spacing: spacingInput
+  });
+  const spacing = (...argsInput) => {
+    if (process.env.NODE_ENV !== "production") {
+      if (!(argsInput.length <= 4)) {
+        console.error(`MUI: Too many arguments provided, expected between 0 and 4, got ${argsInput.length}`);
+      }
+    }
+    const args = argsInput.length === 0 ? [1] : argsInput;
+    return args.map((argument) => {
+      const output = transform(argument);
+      return typeof output === "number" ? `${output}px` : output;
+    }).join(" ");
+  };
+  spacing.mui = true;
+  return spacing;
+}
+export {
+  createSpacing as default
+};

package/dist/node_modules/@mui/system/esm/createTheme/createTheme.js

@@ -0,0 +1,44 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import createBreakpoints from "./createBreakpoints.js";
+import shape from "./shape.js";
+import createSpacing from "./createSpacing.js";
+import styleFunctionSx from "../styleFunctionSx/styleFunctionSx.js";
+import defaultSxConfig from "../styleFunctionSx/defaultSxConfig.js";
+import applyStyles from "./applyStyles.js";
+import deepmerge from "../../node_modules/@mui/utils/esm/deepmerge/deepmerge.js";
+const _excluded = ["breakpoints", "palette", "spacing", "shape"];
+function createTheme(options = {}, ...args) {
+  const {
+    breakpoints: breakpointsInput = {},
+    palette: paletteInput = {},
+    spacing: spacingInput,
+    shape: shapeInput = {}
+  } = options, other = _objectWithoutPropertiesLoose(options, _excluded);
+  const breakpoints = createBreakpoints(breakpointsInput);
+  const spacing = createSpacing(spacingInput);
+  let muiTheme = deepmerge({
+    breakpoints,
+    direction: "ltr",
+    components: {},
+    // Inject component definitions.
+    palette: _extends({
+      mode: "light"
+    }, paletteInput),
+    spacing,
+    shape: _extends({}, shape, shapeInput)
+  }, other);
+  muiTheme.applyStyles = applyStyles;
+  muiTheme = args.reduce((acc, argument) => deepmerge(acc, argument), muiTheme);
+  muiTheme.unstable_sxConfig = _extends({}, defaultSxConfig, other == null ? void 0 : other.unstable_sxConfig);
+  muiTheme.unstable_sx = function sx(props) {
+    return styleFunctionSx({
+      sx: props,
+      theme: this
+    });
+  };
+  return muiTheme;
+}
+export {
+  createTheme as default
+};

package/dist/node_modules/@mui/system/esm/createTheme/index.js

@@ -0,0 +1,8 @@
+import { default as default2 } from "./createTheme.js";
+import { default as default3 } from "./createBreakpoints.js";
+import { default as default4 } from "./applyStyles.js";
+export {
+  default2 as default,
+  default3 as private_createBreakpoints,
+  default4 as unstable_applyStyles
+};

package/dist/node_modules/@mui/system/esm/createTheme/shape.js

@@ -0,0 +1,6 @@
+const shape = {
+  borderRadius: 4
+};
+export {
+  shape as default
+};

package/dist/node_modules/@mui/system/esm/cssGrid.js

@@ -0,0 +1,89 @@
+import style from "./style.js";
+import compose from "./compose.js";
+import { createUnaryUnit, getValue } from "./spacing.js";
+import { handleBreakpoints } from "./breakpoints.js";
+import responsivePropType from "./responsivePropType.js";
+const gap = (props) => {
+  if (props.gap !== void 0 && props.gap !== null) {
+    const transformer = createUnaryUnit(props.theme, "spacing", 8, "gap");
+    const styleFromPropValue = (propValue) => ({
+      gap: getValue(transformer, propValue)
+    });
+    return handleBreakpoints(props, props.gap, styleFromPropValue);
+  }
+  return null;
+};
+gap.propTypes = process.env.NODE_ENV !== "production" ? {
+  gap: responsivePropType
+} : {};
+gap.filterProps = ["gap"];
+const columnGap = (props) => {
+  if (props.columnGap !== void 0 && props.columnGap !== null) {
+    const transformer = createUnaryUnit(props.theme, "spacing", 8, "columnGap");
+    const styleFromPropValue = (propValue) => ({
+      columnGap: getValue(transformer, propValue)
+    });
+    return handleBreakpoints(props, props.columnGap, styleFromPropValue);
+  }
+  return null;
+};
+columnGap.propTypes = process.env.NODE_ENV !== "production" ? {
+  columnGap: responsivePropType
+} : {};
+columnGap.filterProps = ["columnGap"];
+const rowGap = (props) => {
+  if (props.rowGap !== void 0 && props.rowGap !== null) {
+    const transformer = createUnaryUnit(props.theme, "spacing", 8, "rowGap");
+    const styleFromPropValue = (propValue) => ({
+      rowGap: getValue(transformer, propValue)
+    });
+    return handleBreakpoints(props, props.rowGap, styleFromPropValue);
+  }
+  return null;
+};
+rowGap.propTypes = process.env.NODE_ENV !== "production" ? {
+  rowGap: responsivePropType
+} : {};
+rowGap.filterProps = ["rowGap"];
+const gridColumn = style({
+  prop: "gridColumn"
+});
+const gridRow = style({
+  prop: "gridRow"
+});
+const gridAutoFlow = style({
+  prop: "gridAutoFlow"
+});
+const gridAutoColumns = style({
+  prop: "gridAutoColumns"
+});
+const gridAutoRows = style({
+  prop: "gridAutoRows"
+});
+const gridTemplateColumns = style({
+  prop: "gridTemplateColumns"
+});
+const gridTemplateRows = style({
+  prop: "gridTemplateRows"
+});
+const gridTemplateAreas = style({
+  prop: "gridTemplateAreas"
+});
+const gridArea = style({
+  prop: "gridArea"
+});
+compose(gap, columnGap, rowGap, gridColumn, gridRow, gridAutoFlow, gridAutoColumns, gridAutoRows, gridTemplateColumns, gridTemplateRows, gridTemplateAreas, gridArea);
+export {
+  columnGap,
+  gap,
+  gridArea,
+  gridAutoColumns,
+  gridAutoFlow,
+  gridAutoRows,
+  gridColumn,
+  gridRow,
+  gridTemplateAreas,
+  gridTemplateColumns,
+  gridTemplateRows,
+  rowGap
+};

package/dist/node_modules/@mui/system/esm/memoize.js

@@ -0,0 +1,12 @@
+function memoize(fn) {
+  const cache = {};
+  return (arg) => {
+    if (cache[arg] === void 0) {
+      cache[arg] = fn(arg);
+    }
+    return cache[arg];
+  };
+}
+export {
+  memoize as default
+};

package/dist/node_modules/@mui/system/esm/merge.js

@@ -0,0 +1,13 @@
+import deepmerge from "../node_modules/@mui/utils/esm/deepmerge/deepmerge.js";
+function merge(acc, item) {
+  if (!item) {
+    return acc;
+  }
+  return deepmerge(acc, item, {
+    clone: false
+    // No need to clone deep, it's way faster.
+  });
+}
+export {
+  merge as default
+};

package/dist/node_modules/@mui/system/esm/palette.js

@@ -0,0 +1,31 @@
+import style from "./style.js";
+import compose from "./compose.js";
+function paletteTransform(value, userValue) {
+  if (userValue === "grey") {
+    return userValue;
+  }
+  return value;
+}
+const color = style({
+  prop: "color",
+  themeKey: "palette",
+  transform: paletteTransform
+});
+const bgcolor = style({
+  prop: "bgcolor",
+  cssProperty: "backgroundColor",
+  themeKey: "palette",
+  transform: paletteTransform
+});
+const backgroundColor = style({
+  prop: "backgroundColor",
+  themeKey: "palette",
+  transform: paletteTransform
+});
+compose(color, bgcolor, backgroundColor);
+export {
+  backgroundColor,
+  bgcolor,
+  color,
+  paletteTransform
+};

package/dist/node_modules/@mui/system/esm/responsivePropType.js

@@ -0,0 +1,5 @@
+import PropTypes from "../../../prop-types/index.js";
+const responsivePropType = process.env.NODE_ENV !== "production" ? PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.object, PropTypes.array]) : {};
+export {
+  responsivePropType as default
+};

package/dist/node_modules/@mui/system/esm/sizing.js

@@ -0,0 +1,74 @@
+import style from "./style.js";
+import compose from "./compose.js";
+import { handleBreakpoints, values } from "./breakpoints.js";
+function sizingTransform(value) {
+  return value <= 1 && value !== 0 ? `${value * 100}%` : value;
+}
+const width = style({
+  prop: "width",
+  transform: sizingTransform
+});
+const maxWidth = (props) => {
+  if (props.maxWidth !== void 0 && props.maxWidth !== null) {
+    const styleFromPropValue = (propValue) => {
+      var _props$theme, _props$theme2;
+      const breakpoint = ((_props$theme = props.theme) == null || (_props$theme = _props$theme.breakpoints) == null || (_props$theme = _props$theme.values) == null ? void 0 : _props$theme[propValue]) || values[propValue];
+      if (!breakpoint) {
+        return {
+          maxWidth: sizingTransform(propValue)
+        };
+      }
+      if (((_props$theme2 = props.theme) == null || (_props$theme2 = _props$theme2.breakpoints) == null ? void 0 : _props$theme2.unit) !== "px") {
+        return {
+          maxWidth: `${breakpoint}${props.theme.breakpoints.unit}`
+        };
+      }
+      return {
+        maxWidth: breakpoint
+      };
+    };
+    return handleBreakpoints(props, props.maxWidth, styleFromPropValue);
+  }
+  return null;
+};
+maxWidth.filterProps = ["maxWidth"];
+const minWidth = style({
+  prop: "minWidth",
+  transform: sizingTransform
+});
+const height = style({
+  prop: "height",
+  transform: sizingTransform
+});
+const maxHeight = style({
+  prop: "maxHeight",
+  transform: sizingTransform
+});
+const minHeight = style({
+  prop: "minHeight",
+  transform: sizingTransform
+});
+style({
+  prop: "size",
+  cssProperty: "width",
+  transform: sizingTransform
+});
+style({
+  prop: "size",
+  cssProperty: "height",
+  transform: sizingTransform
+});
+const boxSizing = style({
+  prop: "boxSizing"
+});
+compose(width, maxWidth, minWidth, height, maxHeight, minHeight, boxSizing);
+export {
+  boxSizing,
+  height,
+  maxHeight,
+  maxWidth,
+  minHeight,
+  minWidth,
+  sizingTransform,
+  width
+};