@ceed/cds 0.0.186 → 0.0.187-cjs.0

package/dist/external/@mui/system/esm/styleFunctionSx/defaultSxConfig.js

@@ -0,0 +1,295 @@
+'use strict';
+
+var spacing = require('../spacing.js');
+var borders = require('../borders.js');
+var cssGrid = require('../cssGrid.js');
+var palette = require('../palette.js');
+var sizing = require('../sizing.js');
+
+const defaultSxConfig = {
+  // borders
+  border: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  borderTop: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  borderRight: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  borderBottom: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  borderLeft: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  borderColor: {
+    themeKey: 'palette'
+  },
+  borderTopColor: {
+    themeKey: 'palette'
+  },
+  borderRightColor: {
+    themeKey: 'palette'
+  },
+  borderBottomColor: {
+    themeKey: 'palette'
+  },
+  borderLeftColor: {
+    themeKey: 'palette'
+  },
+  outline: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  outlineColor: {
+    themeKey: 'palette'
+  },
+  borderRadius: {
+    themeKey: 'shape.borderRadius',
+    style: borders.borderRadius
+  },
+  // palette
+  color: {
+    themeKey: 'palette',
+    transform: palette.paletteTransform
+  },
+  bgcolor: {
+    themeKey: 'palette',
+    cssProperty: 'backgroundColor',
+    transform: palette.paletteTransform
+  },
+  backgroundColor: {
+    themeKey: 'palette',
+    transform: palette.paletteTransform
+  },
+  // spacing
+  p: {
+    style: spacing.padding
+  },
+  pt: {
+    style: spacing.padding
+  },
+  pr: {
+    style: spacing.padding
+  },
+  pb: {
+    style: spacing.padding
+  },
+  pl: {
+    style: spacing.padding
+  },
+  px: {
+    style: spacing.padding
+  },
+  py: {
+    style: spacing.padding
+  },
+  padding: {
+    style: spacing.padding
+  },
+  paddingTop: {
+    style: spacing.padding
+  },
+  paddingRight: {
+    style: spacing.padding
+  },
+  paddingBottom: {
+    style: spacing.padding
+  },
+  paddingLeft: {
+    style: spacing.padding
+  },
+  paddingX: {
+    style: spacing.padding
+  },
+  paddingY: {
+    style: spacing.padding
+  },
+  paddingInline: {
+    style: spacing.padding
+  },
+  paddingInlineStart: {
+    style: spacing.padding
+  },
+  paddingInlineEnd: {
+    style: spacing.padding
+  },
+  paddingBlock: {
+    style: spacing.padding
+  },
+  paddingBlockStart: {
+    style: spacing.padding
+  },
+  paddingBlockEnd: {
+    style: spacing.padding
+  },
+  m: {
+    style: spacing.margin
+  },
+  mt: {
+    style: spacing.margin
+  },
+  mr: {
+    style: spacing.margin
+  },
+  mb: {
+    style: spacing.margin
+  },
+  ml: {
+    style: spacing.margin
+  },
+  mx: {
+    style: spacing.margin
+  },
+  my: {
+    style: spacing.margin
+  },
+  margin: {
+    style: spacing.margin
+  },
+  marginTop: {
+    style: spacing.margin
+  },
+  marginRight: {
+    style: spacing.margin
+  },
+  marginBottom: {
+    style: spacing.margin
+  },
+  marginLeft: {
+    style: spacing.margin
+  },
+  marginX: {
+    style: spacing.margin
+  },
+  marginY: {
+    style: spacing.margin
+  },
+  marginInline: {
+    style: spacing.margin
+  },
+  marginInlineStart: {
+    style: spacing.margin
+  },
+  marginInlineEnd: {
+    style: spacing.margin
+  },
+  marginBlock: {
+    style: spacing.margin
+  },
+  marginBlockStart: {
+    style: spacing.margin
+  },
+  marginBlockEnd: {
+    style: spacing.margin
+  },
+  // display
+  displayPrint: {
+    cssProperty: false,
+    transform: value => ({
+      '@media print': {
+        display: value
+      }
+    })
+  },
+  display: {},
+  overflow: {},
+  textOverflow: {},
+  visibility: {},
+  whiteSpace: {},
+  // flexbox
+  flexBasis: {},
+  flexDirection: {},
+  flexWrap: {},
+  justifyContent: {},
+  alignItems: {},
+  alignContent: {},
+  order: {},
+  flex: {},
+  flexGrow: {},
+  flexShrink: {},
+  alignSelf: {},
+  justifyItems: {},
+  justifySelf: {},
+  // grid
+  gap: {
+    style: cssGrid.gap
+  },
+  rowGap: {
+    style: cssGrid.rowGap
+  },
+  columnGap: {
+    style: cssGrid.columnGap
+  },
+  gridColumn: {},
+  gridRow: {},
+  gridAutoFlow: {},
+  gridAutoColumns: {},
+  gridAutoRows: {},
+  gridTemplateColumns: {},
+  gridTemplateRows: {},
+  gridTemplateAreas: {},
+  gridArea: {},
+  // positions
+  position: {},
+  zIndex: {
+    themeKey: 'zIndex'
+  },
+  top: {},
+  right: {},
+  bottom: {},
+  left: {},
+  // shadows
+  boxShadow: {
+    themeKey: 'shadows'
+  },
+  // sizing
+  width: {
+    transform: sizing.sizingTransform
+  },
+  maxWidth: {
+    style: sizing.maxWidth
+  },
+  minWidth: {
+    transform: sizing.sizingTransform
+  },
+  height: {
+    transform: sizing.sizingTransform
+  },
+  maxHeight: {
+    transform: sizing.sizingTransform
+  },
+  minHeight: {
+    transform: sizing.sizingTransform
+  },
+  boxSizing: {},
+  // typography
+  fontFamily: {
+    themeKey: 'typography'
+  },
+  fontSize: {
+    themeKey: 'typography'
+  },
+  fontStyle: {
+    themeKey: 'typography'
+  },
+  fontWeight: {
+    themeKey: 'typography'
+  },
+  letterSpacing: {},
+  textTransform: {},
+  lineHeight: {},
+  textAlign: {},
+  typography: {
+    cssProperty: false,
+    themeKey: 'typography'
+  }
+};
+
+module.exports = defaultSxConfig;

package/dist/external/@mui/system/esm/styleFunctionSx/extendSxProp.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var _extends = require('../../../../@babel/runtime/helpers/esm/extends.js');
+var objectWithoutPropertiesLoose = require('../../../../@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js');
+var defaultSxConfig = require('./defaultSxConfig.js');
+var deepmerge = require('../../../utils/deepmerge/deepmerge.js');
+
+const _excluded = ["sx"];
+const splitProps = props => {
+  var _props$theme$unstable, _props$theme;
+  const result = {
+    systemProps: {},
+    otherProps: {}
+  };
+  const config = (_props$theme$unstable = props == null || (_props$theme = props.theme) == null ? undefined : _props$theme.unstable_sxConfig) != null ? _props$theme$unstable : defaultSxConfig;
+  Object.keys(props).forEach(prop => {
+    if (config[prop]) {
+      result.systemProps[prop] = props[prop];
+    } else {
+      result.otherProps[prop] = props[prop];
+    }
+  });
+  return result;
+};
+function extendSxProp(props) {
+  const {
+      sx: inSx
+    } = props,
+    other = objectWithoutPropertiesLoose(props, _excluded);
+  const {
+    systemProps,
+    otherProps
+  } = splitProps(other);
+  let finalSx;
+  if (Array.isArray(inSx)) {
+    finalSx = [systemProps, ...inSx];
+  } else if (typeof inSx === 'function') {
+    finalSx = (...args) => {
+      const result = inSx(...args);
+      if (!deepmerge.isPlainObject(result)) {
+        return systemProps;
+      }
+      return _extends({}, systemProps, result);
+    };
+  } else {
+    finalSx = _extends({}, systemProps, inSx);
+  }
+  return _extends({}, otherProps, {
+    sx: finalSx
+  });
+}
+
+module.exports = extendSxProp;

package/dist/external/@mui/system/esm/styleFunctionSx/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var styleFunctionSx = require('./styleFunctionSx.js');
+var extendSxProp = require('./extendSxProp.js');
+var defaultSxConfig = require('./defaultSxConfig.js');
+
+
+
+exports.default = styleFunctionSx.default;
+exports.unstable_createStyleFunctionSx = styleFunctionSx.unstable_createStyleFunctionSx;
+exports.extendSxProp = extendSxProp;
+exports.unstable_defaultSxConfig = defaultSxConfig;

package/dist/external/@mui/system/esm/styleFunctionSx/styleFunctionSx.js

@@ -0,0 +1,134 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var merge = require('../merge.js');
+var style = require('../style.js');
+var breakpoints = require('../breakpoints.js');
+var defaultSxConfig = require('./defaultSxConfig.js');
+var capitalize = require('../../../utils/capitalize/capitalize.js');
+
+function objectsHaveSameKeys(...objects) {
+  const allKeys = objects.reduce((keys, object) => keys.concat(Object.keys(object)), []);
+  const union = new Set(allKeys);
+  return objects.every(object => union.size === Object.keys(object).length);
+}
+function callIfFn(maybeFn, arg) {
+  return typeof maybeFn === 'function' ? maybeFn(arg) : maybeFn;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function unstable_createStyleFunctionSx() {
+  function getThemeValue(prop, val, theme, config) {
+    const props = {
+      [prop]: val,
+      theme
+    };
+    const options = config[prop];
+    if (!options) {
+      return {
+        [prop]: val
+      };
+    }
+    const {
+      cssProperty = prop,
+      themeKey,
+      transform,
+      style: style$1
+    } = options;
+    if (val == null) {
+      return null;
+    }
+
+    // TODO v6: remove, see https://github.com/mui/material-ui/pull/38123
+    if (themeKey === 'typography' && val === 'inherit') {
+      return {
+        [prop]: val
+      };
+    }
+    const themeMapping = style.getPath(theme, themeKey) || {};
+    if (style$1) {
+      return style$1(props);
+    }
+    const styleFromPropValue = propValueFinal => {
+      let value = style.getStyleValue(themeMapping, transform, propValueFinal);
+      if (propValueFinal === value && typeof propValueFinal === 'string') {
+        // Haven't found value
+        value = style.getStyleValue(themeMapping, transform, `${prop}${propValueFinal === 'default' ? '' : capitalize(propValueFinal)}`, propValueFinal);
+      }
+      if (cssProperty === false) {
+        return value;
+      }
+      return {
+        [cssProperty]: value
+      };
+    };
+    return breakpoints.handleBreakpoints(props, val, styleFromPropValue);
+  }
+  function styleFunctionSx(props) {
+    var _theme$unstable_sxCon;
+    const {
+      sx,
+      theme = {}
+    } = props || {};
+    if (!sx) {
+      return null; // Emotion & styled-components will neglect null
+    }
+    const config = (_theme$unstable_sxCon = theme.unstable_sxConfig) != null ? _theme$unstable_sxCon : defaultSxConfig;
+
+    /*
+     * Receive `sxInput` as object or callback
+     * and then recursively check keys & values to create media query object styles.
+     * (the result will be used in `styled`)
+     */
+    function traverse(sxInput) {
+      let sxObject = sxInput;
+      if (typeof sxInput === 'function') {
+        sxObject = sxInput(theme);
+      } else if (typeof sxInput !== 'object') {
+        // value
+        return sxInput;
+      }
+      if (!sxObject) {
+        return null;
+      }
+      const emptyBreakpoints = breakpoints.createEmptyBreakpointObject(theme.breakpoints);
+      const breakpointsKeys = Object.keys(emptyBreakpoints);
+      let css = emptyBreakpoints;
+      Object.keys(sxObject).forEach(styleKey => {
+        const value = callIfFn(sxObject[styleKey], theme);
+        if (value !== null && value !== undefined) {
+          if (typeof value === 'object') {
+            if (config[styleKey]) {
+              css = merge(css, getThemeValue(styleKey, value, theme, config));
+            } else {
+              const breakpointsValues = breakpoints.handleBreakpoints({
+                theme
+              }, value, x => ({
+                [styleKey]: x
+              }));
+              if (objectsHaveSameKeys(breakpointsValues, value)) {
+                css[styleKey] = styleFunctionSx({
+                  sx: value,
+                  theme
+                });
+              } else {
+                css = merge(css, breakpointsValues);
+              }
+            }
+          } else {
+            css = merge(css, getThemeValue(styleKey, value, theme, config));
+          }
+        }
+      });
+      return breakpoints.removeUnusedBreakpoints(breakpointsKeys, css);
+    }
+    return Array.isArray(sx) ? sx.map(traverse) : traverse(sx);
+  }
+  return styleFunctionSx;
+}
+const styleFunctionSx = unstable_createStyleFunctionSx();
+styleFunctionSx.filterProps = ['sx'];
+
+exports.default = styleFunctionSx;
+exports.unstable_createStyleFunctionSx = unstable_createStyleFunctionSx;

package/dist/external/@mui/system/esm/useTheme.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useThemeWithoutDefault = require('./useThemeWithoutDefault.js');
+var createTheme = require('./createTheme/createTheme.js');
+
+const systemDefaultTheme = createTheme();
+function useTheme(defaultTheme = systemDefaultTheme) {
+  return useThemeWithoutDefault(defaultTheme);
+}
+
+exports.default = useTheme;
+exports.systemDefaultTheme = systemDefaultTheme;

package/dist/external/@mui/system/esm/useThemeProps/getThemeProps.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var resolveProps = require('../../../utils/resolveProps/resolveProps.js');
+
+function getThemeProps(params) {
+  const {
+    theme,
+    name,
+    props
+  } = params;
+  if (!theme || !theme.components || !theme.components[name] || !theme.components[name].defaultProps) {
+    return props;
+  }
+  return resolveProps(theme.components[name].defaultProps, props);
+}
+
+module.exports = getThemeProps;

package/dist/external/@mui/system/esm/useThemeProps/useThemeProps.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var getThemeProps = require('./getThemeProps.js');
+var useTheme = require('../useTheme.js');
+
+function useThemeProps({
+  props,
+  name,
+  defaultTheme,
+  themeId
+}) {
+  let theme = useTheme.default(defaultTheme);
+  if (themeId) {
+    theme = theme[themeId] || theme;
+  }
+  const mergedProps = getThemeProps({
+    theme,
+    name,
+    props
+  });
+  return mergedProps;
+}
+
+module.exports = useThemeProps;

package/dist/external/@mui/system/esm/useThemeWithoutDefault.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var React = require('react');
+var react = require('@emotion/react');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+function isObjectEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}
+function useTheme(defaultTheme = null) {
+  const contextTheme = React__namespace.useContext(react.ThemeContext);
+  return !contextTheme || isObjectEmpty(contextTheme) ? defaultTheme : contextTheme;
+}
+
+module.exports = useTheme;

package/dist/external/@mui/utils/ClassNameGenerator/ClassNameGenerator.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const defaultGenerator = componentName => componentName;
+const createClassNameGenerator = () => {
+  let generate = defaultGenerator;
+  return {
+    configure(generator) {
+      generate = generator;
+    },
+    generate(componentName) {
+      return generate(componentName);
+    },
+    reset() {
+      generate = defaultGenerator;
+    }
+  };
+};
+const ClassNameGenerator = createClassNameGenerator();
+
+module.exports = ClassNameGenerator;

package/dist/external/@mui/utils/capitalize/capitalize.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var formatMuiErrorMessage = require('../formatMuiErrorMessage/formatMuiErrorMessage.js');
+
+// It should to be noted that this function isn't equivalent to `text-transform: capitalize`.
+//
+// A strict capitalization should uppercase the first letter of each word in the sentence.
+// We only handle the first word.
+function capitalize(string) {
+  if (typeof string !== 'string') {
+    throw new Error(process.env.NODE_ENV !== "production" ? `MUI: \`capitalize(string)\` expects a string argument.` : formatMuiErrorMessage(7));
+  }
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+module.exports = capitalize;

package/dist/external/@mui/utils/capitalize/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var capitalize = require('./capitalize.js');
+
+
+
+module.exports = capitalize;

package/dist/external/@mui/utils/clamp/clamp.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function clamp(val, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+  return Math.max(min, Math.min(val, max));
+}
+
+module.exports = clamp;

package/dist/external/@mui/utils/clamp/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var clamp = require('./clamp.js');
+
+
+
+module.exports = clamp;

package/dist/external/@mui/utils/composeClasses/composeClasses.js

@@ -0,0 +1,25 @@
+'use strict';
+
+function composeClasses(slots, getUtilityClass, classes = undefined) {
+  const output = {};
+  Object.keys(slots).forEach(
+  // `Object.keys(slots)` can't be wider than `T` because we infer `T` from `slots`.
+  // @ts-expect-error https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208
+  slot => {
+    output[slot] = slots[slot].reduce((acc, key) => {
+      if (key) {
+        const utilityClass = getUtilityClass(key);
+        if (utilityClass !== '') {
+          acc.push(utilityClass);
+        }
+        if (classes && classes[key]) {
+          acc.push(classes[key]);
+        }
+      }
+      return acc;
+    }, []).join(' ');
+  });
+  return output;
+}
+
+module.exports = composeClasses;