@vitus-labs/rocketstyle 0.45.0 → 0.48.0

package/lib/vitus-labs-rocketstyle.umd.js

@@ -1,679 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@vitus-labs/core'), require('react'), require('hoist-non-react-statics')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@vitus-labs/core', 'react', 'hoist-non-react-statics'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vitusLabsRocketstyle = {}, global.core, global.React, global.hoistNonReactStatics));
-})(this, (function (exports, core, React, hoistNonReactStatics) { 'use strict';
-
-  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-  var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-  var hoistNonReactStatics__default = /*#__PURE__*/_interopDefaultLegacy(hoistNonReactStatics);
-
-  const handleEvent = (e) => {
-      e.preventDefault();
-      e.stopPropagation();
-  };
-  const usePseudoState = (props) => {
-      const [hover, setHover] = React.useState(false);
-      const [focus, setFocus] = React.useState(false);
-      const [pressed, setPressed] = React.useState(false);
-      const onMouseEnter = React.useCallback((e) => {
-          handleEvent(e);
-          setHover(true);
-          if (props.onMouseEnter)
-              props.onMouseEnter(e);
-      }, [props.onMouseEnter]);
-      const onMouseLeave = React.useCallback((e) => {
-          handleEvent(e);
-          setHover(false);
-          setPressed(false);
-          if (props.onMouseLeave)
-              props.onMouseLeave(e);
-      }, [props.onMouseLeave]);
-      const onMouseDown = React.useCallback((e) => {
-          handleEvent(e);
-          setPressed(true);
-          if (props.onMouseDown)
-              props.onMouseDown(e);
-      }, [props.onMouseDown]);
-      const onMouseUp = React.useCallback((e) => {
-          handleEvent(e);
-          setPressed(false);
-          if (props.onMouseUp)
-              props.onMouseUp(e);
-      }, [props.onMouseUp]);
-      const onFocus = React.useCallback((e) => {
-          handleEvent(e);
-          setFocus(true);
-          if (props.onFocus)
-              props.onFocus(e);
-      }, [props.onFocus]);
-      const onBlur = React.useCallback((e) => {
-          handleEvent(e);
-          setFocus(false);
-          if (props.onBlur)
-              props.onBlur(e);
-      }, [props.onBlur]);
-      return {
-          state: {
-              hover,
-              focus,
-              pressed,
-          },
-          events: {
-              onMouseEnter,
-              onMouseLeave,
-              onMouseDown,
-              onMouseUp,
-              onFocus,
-              onBlur,
-          },
-      };
-  };
-
-  /* eslint-disable import/prefer-default-export */
-  const chainOptions = (opts, defaultOpts = []) => {
-      const result = [...defaultOpts];
-      if (typeof opts === 'function')
-          result.push(opts);
-      else if (typeof opts === 'object')
-          result.push(() => opts);
-      return result;
-  };
-  const removeNullableValues = (obj) => Object.entries(obj)
-      .filter(([, v]) => v != null && v !== false)
-      .reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {});
-
-  const isValidKey = (value) => value !== undefined && value !== null && value !== false;
-  const isMultiKey = (value) => {
-      if (typeof value === 'object')
-          return [true, core.get(value, 'propName')];
-      return [false, value];
-  };
-  const calculateDimensionsMap = ({ themes, useBooleans, }) => {
-      const result = { keysMap: {}, keywords: {} };
-      if (core.isEmpty(themes))
-          return result;
-      return Object.entries(themes).reduce((accumulator, [key, value]) => {
-          const { keysMap, keywords } = accumulator;
-          keywords[key] = true;
-          Object.entries(value).forEach(([itemKey, itemValue]) => {
-              if (!isValidKey(itemValue))
-                  return;
-              if (useBooleans) {
-                  keywords[itemKey] = true;
-              }
-              core.set(keysMap, [key, itemKey], true);
-          });
-          return accumulator;
-      }, result);
-  };
-  const getKeys = (obj) => Object.keys(obj);
-  const getValues = (obj) => Object.values(obj);
-  const getDimensionsValues = (obj) => getValues(obj).map((item) => {
-      if (typeof item === 'object') {
-          return item.propName;
-      }
-      return item;
-  });
-  const getMultipleDimensions = (obj) => getValues(obj).reduce((accumulator, value) => {
-      if (typeof value === 'object') {
-          // eslint-disable-next-line no-param-reassign
-          if (value.multi === true)
-              accumulator[value.propName] = true;
-      }
-      return accumulator;
-  }, {});
-
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // --------------------------------------------------------
-  // theme mode callback
-  // --------------------------------------------------------
-  const themeModeCb = (...params) => (mode) => {
-      if (!mode || mode === 'light')
-          return params[0];
-      return params[1];
-  };
-  const calculateDimensionThemes = (theme, options, cb) => {
-      const result = {};
-      if (core.isEmpty(options.dimensions))
-          return result;
-      return Object.entries(options.dimensions).reduce((accumulator, [key, value]) => {
-          const [, dimension] = isMultiKey(value);
-          const helper = options[key];
-          if (Array.isArray(helper) && helper.length > 0) {
-              const finalDimensionThemes = calculateChainOptions$1(helper, [
-                  theme,
-                  cb,
-                  core.config.css,
-              ]);
-              // eslint-disable-next-line no-param-reassign
-              accumulator[dimension] = removeNullableValues(finalDimensionThemes);
-          }
-          return accumulator;
-      }, result);
-  };
-  const calculateChainOptions$1 = (options, args) => {
-      const result = {};
-      if (core.isEmpty(options))
-          return result;
-      return options.reduce((acc, item) => core.merge(acc, item(...args)), result);
-      // using this does not allow overriding themes properly
-      // return removeAllEmptyValues(helper)
-  };
-  const calculateTheme = ({ rocketstate, themes, baseTheme, }) => {
-      // generate final theme which will be passed to styled component
-      let finalTheme = { ...baseTheme };
-      Object.entries(rocketstate).forEach(([key, value]) => {
-          const keyTheme = themes[key];
-          if (Array.isArray(value)) {
-              value.forEach((item) => {
-                  finalTheme = core.merge({}, finalTheme, keyTheme[item]);
-              });
-          }
-          else {
-              finalTheme = core.merge({}, finalTheme, keyTheme[value]);
-          }
-      });
-      return finalTheme;
-  };
-  const calculateThemeMode = (themes, variant) => {
-      const callback = themeModeCb().toString();
-      const isModeCallback = (value) => value.toString() === callback;
-      const result = {};
-      Object.entries(themes).forEach(([key, value]) => {
-          if (typeof value === 'object' && value !== null) {
-              result[key] = calculateThemeMode(value, variant);
-          }
-          else if (typeof value === 'function' && isModeCallback(value)) {
-              result[key] = value(variant);
-          }
-          else {
-              result[key] = value;
-          }
-      });
-      return result;
-  };
-
-  const useTheme = ({ theme, options, cb }) => {
-      const themes = calculateDimensionThemes(theme, options, cb);
-      const { keysMap, keywords } = calculateDimensionsMap({
-          themes,
-          useBooleans: options.useBooleans,
-      });
-      // eslint-disable-next-line no-underscore-dangle
-      const __ROCKETSTYLE__ = {
-          dimensions: keysMap,
-          reservedPropNames: keywords,
-          baseTheme: calculateChainOptions$1(options.theme, [theme, cb, core.config.css]),
-          themes,
-      };
-      return __ROCKETSTYLE__;
-  };
-
-  const Provider = ({ provider = core.Provider, ...props }) => {
-      const ctx = React.useContext(core.context);
-      const { theme, mode, inversed, provider: RocketstyleProvider, children, } = { ...props, ...ctx, provider };
-      const isDark = inversed ? mode !== 'dark' : mode === 'dark';
-      return (React__default["default"].createElement(RocketstyleProvider, { mode: mode, isDark: isDark, isLight: !isDark, theme: theme, provider: provider }, children));
-  };
-
-  const PSEUDO_KEYS = ['hover', 'active', 'focus', 'pressed'];
-  const THEME_MODES = {
-      light: true,
-      dark: true,
-  };
-  const THEME_MODES_INVERSED = {
-      dark: 'light',
-      light: 'dark',
-  };
-  const CONFIG_KEYS = [
-      'provider',
-      'consumer',
-      'DEBUG',
-      'name',
-      'component',
-      'inversed',
-      'passProps',
-      'styled',
-  ];
-  const STYLING_KEYS = ['theme', 'attrs', 'styles'];
-  const STATIC_KEYS = [...STYLING_KEYS, 'compose'];
-  const ALL_RESERVED_KEYS = [
-      ...Object.keys(THEME_MODES),
-      ...CONFIG_KEYS,
-      ...STATIC_KEYS,
-  ];
-
-  const useThemeOptions = ({ inversed }) => {
-      const { theme, mode: ctxMode, isDark: ctxDark } = React.useContext(core.context);
-      const mode = inversed ? THEME_MODES_INVERSED[ctxMode] : ctxMode;
-      const isDark = inversed ? !ctxDark : ctxDark;
-      const isLight = !isDark;
-      return { theme, mode, isDark, isLight };
-  };
-
-  const pickStyledProps = (props, keywords) => {
-      const result = {};
-      Object.entries(props).forEach(([key, value]) => {
-          if (keywords[key])
-              result[key] = value;
-      });
-      return result;
-  };
-  const calculateChainOptions = (options) => (args) => {
-      const result = {};
-      if (core.isEmpty(options))
-          return result;
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      return options.reduce((acc, item) => Object.assign(acc, item(...args)), result);
-  };
-  const calculateStylingAttrs = ({ useBooleans, multiKeys }) => ({ props, dimensions }) => {
-      const result = {};
-      // (1) find dimension keys values & initialize
-      // object with possible options
-      Object.keys(dimensions).forEach((item) => {
-          const pickedProp = props[item];
-          const valueTypes = ['number', 'string'];
-          // if the property is mutli key, allow assign array as well
-          if (multiKeys && multiKeys[item] && Array.isArray(pickedProp)) {
-              result[item] = pickedProp;
-          }
-          // assign when it's only a string or number otherwise it's considered
-          // as invalid param
-          else if (valueTypes.includes(typeof pickedProp)) {
-              result[item] = pickedProp;
-          }
-          else {
-              result[item] = undefined;
-          }
-      });
-      // (2) if booleans are being used let's find the rest
-      if (useBooleans) {
-          const propsKeys = Object.keys(props).reverse();
-          Object.entries(result).forEach(([key, value]) => {
-              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-              // @ts-ignore
-              const isMultiKey = multiKeys[key];
-              // when value in result is not assigned yet
-              if (!value) {
-                  let newDimensionValue;
-                  const keywords = Object.keys(dimensions[key]);
-                  if (isMultiKey) {
-                      newDimensionValue = propsKeys.filter((key) => keywords.includes(key));
-                  }
-                  else {
-                      // reverse props to guarantee the last one will have
-                      // a priority over previous ones
-                      newDimensionValue = propsKeys.find((key) => {
-                          if (keywords.includes(key) && props[key])
-                              return key;
-                          return false;
-                      });
-                  }
-                  result[key] = newDimensionValue;
-              }
-          });
-      }
-      return result;
-  };
-
-  /* eslint-disable no-underscore-dangle */
-  const rocketStyleHOC = ({ inversed, attrs }) => {
-      // --------------------------------------------------
-      // .attrs(...)
-      // first we need to calculate final props which are
-      // being returned by using `attr` chaining method
-      // --------------------------------------------------
-      const _calculateChainOptions = calculateChainOptions(attrs);
-      const Enhanced = (WrappedComponent) => React.forwardRef((props, ref) => {
-          const { theme, mode, isDark, isLight } = useThemeOptions({
-              inversed,
-          });
-          const calculatedAttrs = _calculateChainOptions([
-              props,
-              theme,
-              {
-                  renderContent: core.renderContent,
-                  mode,
-                  isDark,
-                  isLight,
-              },
-          ]);
-          return (React__default["default"].createElement(WrappedComponent, { "$rocketstyleRef": ref, ...calculatedAttrs, ...props }));
-      });
-      return Enhanced;
-  };
-
-  var localContext = React.createContext({});
-
-  const RocketStyleProviderComponent = (WrappedComponent) => React.forwardRef(({ onMouseEnter, onMouseLeave, onMouseUp, onMouseDown, onFocus, onBlur, $rocketstate, ...props }, ref) => {
-      // pseudo hook to detect states hover / pressed / focus
-      const pseudo = usePseudoState({
-          onMouseEnter,
-          onMouseLeave,
-          onMouseUp,
-          onMouseDown,
-          onFocus,
-          onBlur,
-      });
-      const updatedState = React.useMemo(() => ({
-          ...$rocketstate,
-          pseudo: { ...$rocketstate.pseudo, ...pseudo.state },
-      }), [$rocketstate, pseudo]);
-      return (React__default["default"].createElement(localContext.Provider, { value: updatedState },
-          React__default["default"].createElement(WrappedComponent, { ...props, ...pseudo.events, ref: ref, "$rocketstate": updatedState })));
-  });
-
-  const calculateStyles = (styles, css) => {
-      if (!styles)
-          return [];
-      return styles.map((item) => item(css));
-  };
-
-  /* eslint-disable no-underscore-dangle */
-  const orOptions = (keys, opts, defaultOpts) => keys.reduce((acc, item) => ({ ...acc, [item]: opts[item] || defaultOpts[item] }), {});
-  const chainReservedOptions = (keys, opts, defaultOpts) => keys.reduce((acc, item) => ({
-      ...acc,
-      [item]: chainOptions(opts[item], defaultOpts[item]),
-  }), {});
-  // --------------------------------------------------------
-  // helpers for create statics chainin methods on component
-  // --------------------------------------------------------
-  const createStaticsChainingEnhancers = ({ context, dimensionKeys, func, opts, }) => {
-      dimensionKeys.forEach((item) => {
-          // eslint-disable-next-line no-param-reassign
-          context[item] = (props) => func({ [item]: props }, opts);
-      });
-  };
-  // --------------------------------------------------------
-  // helpers for create statics on component
-  // --------------------------------------------------------
-  const createStaticsEnhancers = ({ context, opts }) => {
-      if (!core.isEmpty(opts)) {
-          Object.assign(context, opts);
-      }
-  };
-  const cloneAndEnhance = (opts, defaultOpts) => styleComponent({
-      ...defaultOpts,
-      statics: { ...defaultOpts.statics, ...opts.statics },
-      compose: { ...defaultOpts.compose, ...opts.compose },
-      ...orOptions(CONFIG_KEYS, opts, defaultOpts),
-      ...chainReservedOptions([...defaultOpts.dimensionKeys, ...STYLING_KEYS], opts, defaultOpts),
-  });
-  // --------------------------------------------------------
-  // styleComponent
-  // helper function which allows function chaining
-  // always returns a valid React component with static functions
-  // assigned, so it can be even rendered as a valid component
-  // or styles can be extended via its statics
-  // --------------------------------------------------------
-  const styleComponent = (options) => {
-      const { component, styles } = options;
-      const { styled } = core.config;
-      // const _calculateChainOptions = calculateChainOptions(options.attrs)
-      const _calculateStylingAttrs = calculateStylingAttrs({
-          multiKeys: options.multiKeys,
-          useBooleans: options.useBooleans,
-      });
-      const componentName = options.name || options.component.displayName || options.component.name;
-      // create styled component with all options.styles if available
-      const STYLED_COMPONENT = component.IS_ROCKETSTYLE || options.styled === false
-          ? component
-          : styled(component) `
-          ${calculateStyles(styles, core.config.css)};
-        `;
-      // --------------------------------------------------------
-      // final component to be rendered
-      // --------------------------------------------------------
-      const RenderComponent = options.provider
-          ? RocketStyleProviderComponent(STYLED_COMPONENT)
-          : STYLED_COMPONENT;
-      // --------------------------------------------------------
-      // hocs
-      // --------------------------------------------------------
-      const calculateHocsFuncs = Object.values(options.compose || {})
-          .filter((item) => typeof item === 'function')
-          .reverse();
-      const hocsFuncs = [rocketStyleHOC(options), ...calculateHocsFuncs];
-      // --------------------------------------------------------
-      // ENHANCED COMPONENT (returned component)
-      // --------------------------------------------------------
-      // .attrs() chaining option is calculated in HOC and passed as props already
-      const EnhancedComponent = React.forwardRef(({ $rocketstyleRef, // it's forwarded from HOC which is always on top of hocs
-      ...props }, ref) => {
-          // --------------------------------------------------
-          // handle refs
-          // (1) one is passed from inner HOC - $rocketstyleRef
-          // (2) second one is used to be used directly (e.g. inside hocs)
-          // --------------------------------------------------
-          const internalRef = React.useRef(null);
-          if ($rocketstyleRef)
-              React.useImperativeHandle($rocketstyleRef, () => internalRef.current, [
-                  $rocketstyleRef,
-              ]);
-          if (ref)
-              React.useImperativeHandle(ref, () => internalRef.current, [ref]);
-          // --------------------------------------------------
-          // hover - focus - pressed state passed via context from parent component
-          // --------------------------------------------------
-          const rocketstyleCtx = options.consumer ? React.useContext(localContext) : {};
-          // --------------------------------------------------
-          // general theme and theme mode dark / light passed in context
-          // --------------------------------------------------
-          const { theme, mode } = useThemeOptions(options);
-          // --------------------------------------------------
-          // calculate themes for all possible styling dimensions
-          // .theme(...) + defined dimensions like .states(...), .sizes(...)
-          // --------------------------------------------------
-          const __ROCKETSTYLE__ = React.useMemo(() => useTheme({
-              theme,
-              options,
-              cb: themeModeCb,
-          }), 
-          // recalculate this only when theme changes
-          [theme]);
-          const { reservedPropNames, themes: rocketThemes, dimensions, baseTheme: rocketBaseTheme, } = __ROCKETSTYLE__;
-          const { baseTheme, themes } = React.useMemo(() => calculateThemeMode({ themes: rocketThemes, baseTheme: rocketBaseTheme }, mode), 
-          // recalculate this only when theme mode changes dark / light
-          [mode]);
-          // --------------------------------------------------
-          // calculate reserved Keys defined in dimensions as styling keys
-          // there is no need to calculate this each time - keys are based on
-          // dimensions definitions
-          // --------------------------------------------------
-          const RESERVED_STYLING_PROPS_KEYS = React.useMemo(() => Object.keys(reservedPropNames), []);
-          // --------------------------------------------------
-          // get final props which are (latest has the highest priority):
-          // (1) merged styling from context,
-          // (2) `attrs` chaining method, and from
-          // (3) passing them directly to component
-          // --------------------------------------------------
-          const { pseudo = {}, ...mergeProps } = {
-              ...(options.consumer
-                  ? options.consumer((callback) => callback(rocketstyleCtx))
-                  : {}),
-              ...props,
-          };
-          // --------------------------------------------------
-          // rocketstate
-          // calculate final component state including pseudo state
-          // passed as $rocketstate prop
-          // --------------------------------------------------
-          const rocketstate = _calculateStylingAttrs({
-              props: pickStyledProps(mergeProps, reservedPropNames),
-              dimensions,
-          });
-          // --------------------------------------------------
-          // pseudo state
-          // calculate final component pseudo state including pseudo state
-          // from props and override by pseudo props from context
-          // --------------------------------------------------
-          const finalPseudo = {
-              ...core.pick(props, PSEUDO_KEYS),
-              ...pseudo,
-          };
-          const finalRocketstate = { ...rocketstate, pseudo: finalPseudo };
-          // --------------------------------------------------
-          // rocketstyle
-          // calculated (based on styling props) final theme which will be passed
-          // to our styled component
-          // passed as $rocketstyle prop
-          // --------------------------------------------------
-          const rocketstyle = calculateTheme({
-              rocketstate,
-              themes,
-              baseTheme,
-          });
-          // --------------------------------------------------
-          // final props
-          // final props passed to WrappedComponent
-          // excluding: styling props
-          // including: $rocketstyle, $rocketstate
-          // --------------------------------------------------
-          const finalProps = {
-              // this removes styling state from props and passes its state
-              // under rocketstate key only
-              ...core.omit(mergeProps, [...RESERVED_STYLING_PROPS_KEYS, ...PSEUDO_KEYS]),
-              // if enforced to pass styling props, we pass them directly
-              ...(options.passProps ? core.pick(mergeProps, options.passProps) : {}),
-              ref: ref || $rocketstyleRef ? internalRef : undefined,
-              // state props passed to styled component only, therefore the `$` symbol
-              $rocketstyle: rocketstyle,
-              $rocketstate: finalRocketstate,
-          };
-          // all the development stuff injected
-          if (process.env.NODE_ENV !== 'production') {
-              finalProps['data-rocketstyle'] = componentName;
-          }
-          return React__default["default"].createElement(RenderComponent, { ...finalProps });
-      });
-      // ------------------------------------------------------
-      // This will hoist and generate dynamically next static methods
-      // for all dimensions available in configuration
-      // ------------------------------------------------------
-      const RocketComponent = core.compose(...hocsFuncs)(EnhancedComponent);
-      RocketComponent.IS_ROCKETSTYLE = true;
-      RocketComponent.displayName = componentName;
-      hoistNonReactStatics__default["default"](RocketComponent, options.component);
-      // ------------------------------------------------------
-      // enhance for chaining methods
-      // ------------------------------------------------------
-      createStaticsChainingEnhancers({
-          context: RocketComponent,
-          dimensionKeys: [...options.dimensionKeys, ...STATIC_KEYS],
-          func: cloneAndEnhance,
-          opts: options,
-      });
-      // ------------------------------------------------------
-      RocketComponent.IS_ROCKETSTYLE = true;
-      RocketComponent.displayName = componentName;
-      RocketComponent.is = {};
-      // ------------------------------------------------------
-      // ------------------------------------------------------
-      // enhance for statics
-      // ------------------------------------------------------
-      createStaticsEnhancers({
-          context: RocketComponent.is,
-          opts: options.statics,
-      });
-      RocketComponent.config = (opts = {}) => {
-          const result = core.pick(opts, CONFIG_KEYS);
-          return cloneAndEnhance(result, options);
-      };
-      RocketComponent.statics = (opts = {}) => cloneAndEnhance({ statics: opts }, options);
-      RocketComponent.getStaticDimensions = (theme) => {
-          const themes = useTheme({ theme, options, cb: themeModeCb });
-          return {
-              dimensions: themes.dimensions,
-              useBooleans: options.useBooleans,
-              multiKeys: options.multiKeys,
-          };
-      };
-      RocketComponent.getDefaultAttrs = (props, theme, mode) => {
-          const result = calculateChainOptions(options.attrs)([
-              props,
-              theme,
-              {
-                  renderContent: core.renderContent,
-                  mode,
-                  isDark: mode === 'light',
-                  isLight: mode === 'dark',
-              },
-          ]);
-          return result;
-      };
-      return RocketComponent;
-  };
-
-  const DEFAULT_DIMENSIONS = {
-      states: 'state',
-      sizes: 'size',
-      variants: 'variant',
-      multiple: {
-          propName: 'multiple',
-          multi: true,
-      },
-  };
-
-  /* eslint-disable @typescript-eslint/ban-types */
-  const rocketstyle = () => ({ dimensions = DEFAULT_DIMENSIONS, useBooleans = true } = {}) => ({ name, component }) => {
-      // --------------------------------------------------------
-      // handle ERRORS in development mode
-      // --------------------------------------------------------
-      if (process.env.NODE_ENV !== 'production') {
-          const errors = {};
-          if (!component) {
-              errors.component = 'Parameter `component` is missing in params!';
-          }
-          if (!name) {
-              errors.name = 'Parameter `name` is missing in params!';
-          }
-          if (core.isEmpty(dimensions)) {
-              errors.dimensions = 'Parameter `dimensions` is missing in params!';
-          }
-          else {
-              const definedDimensions = getKeys(dimensions);
-              const invalidDimension = ALL_RESERVED_KEYS.some((item) => definedDimensions.includes(item));
-              if (invalidDimension) {
-                  errors.invalidDimensions = `Some of your \`dimensions\` is invalid and uses reserved static keys which are
-          ${DEFAULT_DIMENSIONS.toString()}`;
-              }
-          }
-          if (!core.isEmpty(errors)) {
-              throw Error(JSON.stringify(errors));
-          }
-      }
-      return styleComponent({
-          name,
-          component,
-          useBooleans,
-          dimensions,
-          dimensionKeys: getKeys(dimensions),
-          dimensionValues: getDimensionsValues(dimensions),
-          multiKeys: getMultipleDimensions(dimensions),
-      });
-  };
-
-  const isRocketComponent = (component) => {
-      if (typeof component === 'object' &&
-          component !== null &&
-          component.IS_ROCKETSTYLE) {
-          return true;
-      }
-      return false;
-  };
-
-  Object.defineProperty(exports, 'context', {
-    enumerable: true,
-    get: function () { return core.context; }
-  });
-  exports.Provider = Provider;
-  exports["default"] = rocketstyle;
-  exports.isRocketComponent = isRocketComponent;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
-//# sourceMappingURL=vitus-labs-rocketstyle.umd.js.map