linear-react-components-ui 1.1.20-beta.33 → 1.1.20-beta.34

package/lib/icons/index.d.ts

@@ -0,0 +1,15 @@
+import { IconProps } from './types.js';
+import 'react';
+import '../@types/PointerEvents.js';
+import '../@types/SizePixels.js';
+import '../@types/Icon.js';
+import './helper.js';
+import '../@types/Position.js';
+import '../@types/ColorStyles.js';
+
+declare const _default: {
+    (props: IconProps): JSX.Element;
+    displayName: string;
+};
+
+export { _default as default };

package/lib/icons/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _helper = _interopRequireDefault(require("./helper"));
+var _withTooltip = _interopRequireDefault(require("../internals/withTooltip"));
+require("../assets/styles/icon.scss");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const listIcon = _helper.default;
+const disabledIconColor = 'rgb(193, 193, 193)';
+const Icon = _ref => {
+  let {
+    name,
+    onClick,
+    svgStruct,
+    size = 16,
+    style = {},
+    visible = true,
+    disabled = false,
+    customClass = '',
+    customClassForContainer = '',
+    colorStyle = 'default',
+    color,
+    viewBox,
+    pointerEvents = 'none',
+    targetRef,
+    tooltip
+  } = _ref;
+  const isUsingColorStyle = colorStyle !== 'default';
+  const colorFromProp = isUsingColorStyle || !color ? undefined : color;
+  const refSvg = (0, _react.useRef)(null);
+  const viewBoxFromIconOrSvgStrcut = name ? listIcon[name].viewbox : svgStruct?.viewbox;
+  const getPaths = () => name ? listIcon[name].paths : svgStruct?.paths;
+  const getSvg = () => /*#__PURE__*/_react.default.createElement("svg", {
+    "data-testid": "icon",
+    "data-color-style": colorStyle,
+    onClick: () => {
+      if (onClick && !disabled) onClick();
+    },
+    ref: r => {
+      refSvg.current = r;
+    },
+    width: `${size}px`,
+    height: `${size}px`,
+    fill: disabled ? disabledIconColor : colorFromProp,
+    viewBox: viewBox || viewBoxFromIconOrSvgStrcut,
+    className: `icon-component ${customClass}`,
+    pointerEvents: pointerEvents,
+    style: style
+  }, getPaths()?.map(value => /*#__PURE__*/_react.default.createElement("path", {
+    "data-testid": "icon-path",
+    d: value,
+    key: value
+  })));
+  if (color && colorStyle !== 'default') throw new Error('Expected only one of the two properties: colorStyle or color');
+  if (!name && !svgStruct) throw new Error('One of the "name" and "svgStruct" props must be filled');
+  if (!visible) return null;
+  if (!tooltip) return getSvg();
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: `icon-component-container ${customClassForContainer}`,
+    ref: r => {
+      if (targetRef && r) targetRef(r);
+    }
+  }, getSvg());
+};
+var _default = exports.default = (0, _withTooltip.default)(Icon);

package/lib/icons/types.d.ts

@@ -0,0 +1,49 @@
+import { CSSProperties } from 'react';
+import { PointerEvents } from '../@types/PointerEvents.js';
+import { SizePixels } from '../@types/SizePixels.js';
+import { IconNames } from '../@types/Icon.js';
+import { Position } from '../@types/Position.js';
+import { ColorStyles } from '../@types/ColorStyles.js';
+import './helper.js';
+
+type ListIconType = {
+    [name: string]: {
+        viewbox: string;
+        paths: Array<string>;
+    };
+};
+type SvgStruct = {
+    viewbox: string;
+    paths: Array<string>;
+};
+type BaseIconProps = {
+    size?: SizePixels;
+    customClass?: string;
+    customClassForContainer?: string;
+    style?: CSSProperties;
+    visible?: boolean;
+    disabled?: boolean;
+    pointerEvents?: PointerEvents;
+    viewBox?: string;
+    onClick?: () => void;
+    tooltipPosition?: Exclude<Position, 'center'>;
+    tooltipWidth?: string | number;
+    tooltip?: string;
+    targetRef?: (ref: HTMLDivElement) => void;
+};
+type ColorProps = ({
+    colorStyle?: ColorStyles | 'default';
+    color?: null;
+} | {
+    color?: string;
+    colorStyle?: undefined;
+});
+type IconProps = BaseIconProps & ColorProps & ({
+    name: IconNames;
+    svgStruct?: null;
+} | {
+    svgStruct: SvgStruct;
+    name?: null;
+});
+
+export { IconProps, ListIconType };

package/lib/icons/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/index.d.ts

@@ -0,0 +1,39 @@
+export { default as Panel } from './panel/Default.js';
+export { default as Toolbar } from './toolbar/index.js';
+export { default as Button } from './buttons/Button.js';
+export { default as Label } from './labels/DefaultLabel.js';
+export { default as Icon } from './icons/index.js';
+export { default as List } from './list/index.js';
+export { default as Radio } from './radio/index.js';
+export { default as Tab } from './tabs/index.js';
+export { default as Dialog } from './dialog/base/index.js';
+import './panel/types.js';
+import 'react';
+import './@types/PermissionAttr.js';
+import './internals/colorStyles.js';
+import './@types/Icon.js';
+import './icons/helper.js';
+import './toolbar/ToolBarGroup.js';
+import './toolbar/types.js';
+import './@types/ButtonTypes.js';
+import './@types/Position.js';
+import './@types/Size.js';
+import './treeview/types.js';
+import './toolbar/Separator.js';
+import './toolbar/ButtonBar.js';
+import './toolbar/LabelBar.js';
+import './buttons/types.js';
+import './labels/types.js';
+import './icons/types.js';
+import './@types/PointerEvents.js';
+import './@types/SizePixels.js';
+import './@types/ColorStyles.js';
+import './list/Header.js';
+import './list/types.js';
+import './list/Item.js';
+import './list/Separator.js';
+import './radio/types.js';
+import './tabs/Panel.js';
+import './tabs/types.js';
+import './dialog/types.js';
+import './@types/Align.js';

package/lib/index.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Button", {
+  enumerable: true,
+  get: function () {
+    return _buttons.default;
+  }
+});
+Object.defineProperty(exports, "Dialog", {
+  enumerable: true,
+  get: function () {
+    return _base.default;
+  }
+});
+Object.defineProperty(exports, "Icon", {
+  enumerable: true,
+  get: function () {
+    return _icons.default;
+  }
+});
+Object.defineProperty(exports, "Label", {
+  enumerable: true,
+  get: function () {
+    return _labels.default;
+  }
+});
+Object.defineProperty(exports, "List", {
+  enumerable: true,
+  get: function () {
+    return _list.default;
+  }
+});
+Object.defineProperty(exports, "Panel", {
+  enumerable: true,
+  get: function () {
+    return _panel.default;
+  }
+});
+Object.defineProperty(exports, "Radio", {
+  enumerable: true,
+  get: function () {
+    return _radio.default;
+  }
+});
+Object.defineProperty(exports, "Tab", {
+  enumerable: true,
+  get: function () {
+    return _tabs.default;
+  }
+});
+Object.defineProperty(exports, "Toolbar", {
+  enumerable: true,
+  get: function () {
+    return _toolbar.default;
+  }
+});
+var _panel = _interopRequireDefault(require("./panel"));
+var _toolbar = _interopRequireDefault(require("./toolbar"));
+var _buttons = _interopRequireDefault(require("./buttons"));
+var _labels = _interopRequireDefault(require("./labels"));
+var _icons = _interopRequireDefault(require("./icons"));
+var _list = _interopRequireDefault(require("./list"));
+var _radio = _interopRequireDefault(require("./radio"));
+var _tabs = _interopRequireDefault(require("./tabs"));
+var _base = _interopRequireDefault(require("./dialog/base"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/inputs/base/InputTextBase.d.ts

@@ -0,0 +1,11 @@
+import { IBaseProps } from './types.js';
+import 'react';
+import '../../@types/Align.js';
+import '../../@types/Period.js';
+import '../../@types/PermissionAttr.js';
+import '../../internals/types.js';
+import '../../@types/Position.js';
+
+declare const _default: (props: IBaseProps) => JSX.Element;
+
+export { _default as default };

package/lib/inputs/base/InputTextBase.js

@@ -0,0 +1,261 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _inputHOC = _interopRequireDefault(require("../inputHOC"));
+require("../../assets/styles/input.scss");
+var helpers = _interopRequireWildcard(require("./helpers"));
+var _withTooltip = _interopRequireDefault(require("../../internals/withTooltip"));
+var _permissionValidations = require("../../permissionValidations");
+var _hint = _interopRequireDefault(require("../../hint"));
+var _errorMessage = require("../errorMessage");
+var _textContent = _interopRequireDefault(require("../../textContent"));
+var _popover = _interopRequireDefault(require("../../popover"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const InputTextBase = props => {
+  const {
+    textAlign = 'left',
+    value,
+    type = 'text',
+    readOnly = false,
+    placeHolder,
+    required,
+    leftElements,
+    rightElements,
+    children,
+    customClass,
+    customClassForInputContent,
+    customClassForLabel,
+    customClassForSideButtons,
+    inputRef,
+    inputBaseRef,
+    label,
+    labelUppercase,
+    hint,
+    hintPosition = 'below',
+    errorMessages,
+    visible = true,
+    permissionAttr,
+    onDeniedActions,
+    handlerSetOnDenied,
+    targetRef,
+    skeletonize = false,
+    style,
+    styleForInputContent,
+    styleForWrapper,
+    styleForLabel,
+    styleForSideButtons,
+    disabled = false,
+    autoFocus,
+    maxLength,
+    name,
+    id,
+    multiple = false,
+    accept,
+    onChange,
+    onDragOver,
+    onDrop,
+    onDragLeave,
+    onClick,
+    readOnlyClass,
+    autoComplete = 'on',
+    themePopover = 'light',
+    popoverAlign = 'left'
+  } = props;
+  let propsInput;
+  const options = [_permissionValidations.OPTIONS_ON_DENIED.disabled, _permissionValidations.OPTIONS_ON_DENIED.unvisible, _permissionValidations.OPTIONS_ON_DENIED.readOnly, _permissionValidations.OPTIONS_ON_DENIED.hideContent];
+  const labelRef = (0, _react.useRef)(null);
+  const onDenied = onDeniedActions || (0, _permissionValidations.actionsOnPermissionDenied)(options, permissionAttr);
+  const {
+    hideContent,
+    unvisible
+  } = onDenied;
+  const [showTooltip, setShowTooltip] = (0, _react.useState)(false);
+  (0, _react.useEffect)(() => {
+    if (handlerSetOnDenied) handlerSetOnDenied(onDenied);
+  }, []);
+  const applyTabIndex = () => readOnly ? -1 : 0;
+  const shouldDisable = () => disabled || onDenied.disabled;
+  const shouldBeReadOnly = () => readOnly || onDenied.readOnly;
+  const inputProps = () => {
+    const disableCallbacks = shouldBeReadOnly() || shouldDisable() || hideContent;
+    propsInput = {
+      value: hideContent ? '' : value,
+      accept,
+      type,
+      readOnly: shouldBeReadOnly(),
+      placeholder: placeHolder,
+      disabled: shouldDisable() || hideContent,
+      autoFocus,
+      maxLength,
+      name,
+      id,
+      multiple,
+      className: helpers.getInputClass({
+        textAlign,
+        readOnly,
+        readOnlyClass
+      }),
+      ref: r => {
+        if (inputRef) {
+          if (!_lodash.default.isFunction(inputRef)) {
+            inputRef.current = r;
+          } else {
+            inputRef(r);
+          }
+        }
+        if (targetRef) targetRef(r);
+      }
+    };
+    if (!disableCallbacks) {
+      propsInput = _objectSpread(_objectSpread({}, propsInput), {}, {
+        onFocus: e => {
+          props.onInputReceiveFocus?.();
+          if (props.onFocus) props.onFocus(e);
+        },
+        onBlur: e => {
+          props.onInputLostFocus?.();
+          if (props.onBlur) props.onBlur(e);
+        },
+        onKeyDown: e => {
+          if (props.onKeyDown) props.onKeyDown(e);
+        },
+        onKeyPress: e => {
+          if (props.onKeyPress) props.onKeyPress(e);
+        },
+        onChange: e => {
+          if (onChange) onChange(e);
+        },
+        onDragOver: e => {
+          if (onDragOver) onDragOver(e);
+        },
+        onDrop: e => {
+          if (onDrop) onDrop(e);
+        },
+        onDragLeave: e => {
+          if (onDragLeave) onDragLeave(e);
+        },
+        onClick: e => {
+          if (onClick) onClick(e);
+        }
+      });
+    }
+    return propsInput;
+  };
+  const onHoverLabel = e => {
+    const target = e.target;
+    if (target.offsetWidth < target.scrollWidth) {
+      setShowTooltip(true);
+    }
+  };
+  (0, _react.useEffect)(() => {
+    const resize = new ResizeObserver(_ref => {
+      let [element] = _ref;
+      const {
+        target
+      } = element;
+      setShowTooltip(prevState => {
+        var overflowing = target.clientWidth < target.scrollWidth;
+        return prevState === overflowing ? prevState : overflowing;
+      });
+    });
+    if (labelRef.current) {
+      resize.observe(labelRef.current);
+    }
+    return () => {
+      if (resize) {
+        resize.disconnect();
+      }
+    };
+  }, []);
+  if (labelRef.current) {
+    const element = labelRef.current;
+    const overflowing = element.offsetWidth < element.scrollWidth;
+    if (overflowing && !showTooltip) {
+      setShowTooltip(true);
+    }
+  }
+  if (!visible || unvisible) return null;
+  return /*#__PURE__*/_react.default.createElement("div", {
+    style: style,
+    className: `input-base-component ${skeletonize ? '-skeletonized' : ''} ${customClass}`,
+    ref: inputBaseRef
+  }, label && /*#__PURE__*/_react.default.createElement("div", {
+    className: "labelcontainer",
+    style: {
+      textAlign: textAlign === 'center' ? 'left' : textAlign
+    }
+  }, /*#__PURE__*/_react.default.createElement(_textContent.default, {
+    labelRef: labelRef,
+    required: required,
+    label: label,
+    onHoverLabel: onHoverLabel,
+    className: customClassForLabel,
+    labelUppercase: labelUppercase,
+    tooltip: label.toString(),
+    tooltipPosition: "top"
+  }), /*#__PURE__*/_react.default.createElement("div", {
+    className: "text-content",
+    style: {
+      display: 'flex'
+    }
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: `label ${customClassForLabel} ${labelUppercase && ' -uppercase'}`,
+    style: {
+      alignSelf: 'center'
+    }
+  }, label, required && /*#__PURE__*/_react.default.createElement("span", {
+    className: "-requiredlabel"
+  }, "*"), !!hint && hintPosition === 'onLabelRight' && !skeletonize && /*#__PURE__*/_react.default.createElement(_popover.default, {
+    theme: themePopover,
+    align: popoverAlign,
+    customClass: "-hint",
+    iconColor: "#03bde2",
+    style: {
+      margin: '0px 5px',
+      height: 'auto',
+      width: 20
+    }
+  }, hint))), /*#__PURE__*/_react.default.createElement(_textContent.default, null)), /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": "testInputWrapper",
+    style: styleForWrapper,
+    className: helpers.getInputWrapperClass(_objectSpread(_objectSpread({}, props), {}, {
+      disabled: shouldDisable() || hideContent
+    }))
+  }, leftElements && /*#__PURE__*/_react.default.createElement("div", {
+    style: styleForSideButtons,
+    className: `sidebuttons ${customClassForSideButtons}`
+  }, leftElements), /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": "testInputContent",
+    style: styleForInputContent,
+    className: `inputcontent ${customClassForInputContent}`
+  }, type === 'textarea' ? /*#__PURE__*/_react.default.createElement("textarea", _extends({
+    rows: props.rows,
+    cols: props.cols,
+    tabIndex: applyTabIndex()
+  }, inputProps())) : /*#__PURE__*/_react.default.createElement("input", _extends({
+    autoComplete: autoComplete,
+    tabIndex: applyTabIndex(),
+    "data-testid": "teste-123"
+  }, inputProps())), children), helpers.getRightElements(errorMessages || [], skeletonize, rightElements)), /*#__PURE__*/_react.default.createElement(_hint.default, {
+    disabled: disabled,
+    visible: !!hint && hintPosition === 'below',
+    customClass: "hint",
+    description: hint
+  }), /*#__PURE__*/_react.default.createElement(_errorMessage.ErrorMessage, {
+    messages: errorMessages
+  }));
+};
+var _default = exports.default = (0, _inputHOC.default)((0, _withTooltip.default)(InputTextBase));

package/lib/inputs/base/Label.d.ts

@@ -0,0 +1,14 @@
+import { InputLabelProps } from './types.js';
+import 'react';
+import '../../@types/Align.js';
+import '../../@types/Period.js';
+import '../../@types/PermissionAttr.js';
+import '../../internals/types.js';
+import '../../@types/Position.js';
+
+declare const _default: {
+    (props: InputLabelProps): JSX.Element;
+    displayName: string;
+};
+
+export { _default as default };

package/lib/inputs/base/Label.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _withTooltip = _interopRequireDefault(require("../../internals/withTooltip"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const Label = props => {
+  const {
+    label,
+    styleForLabel,
+    customClassForLabel,
+    labelUppercase,
+    required,
+    targetRef,
+    labelRef,
+    onHoverLabel
+  } = props;
+  return /*#__PURE__*/_react.default.createElement("span", {
+    style: styleForLabel,
+    ref: ref => {
+      if (ref) {
+        if (labelRef) labelRef.current = ref;
+        if (targetRef) targetRef(ref);
+      }
+    },
+    onMouseEnter: onHoverLabel,
+    className: `label ${customClassForLabel} ${labelUppercase && ' -uppercase'}`
+  }, label, required && /*#__PURE__*/_react.default.createElement("span", {
+    className: "-requiredlabel"
+  }, "*"));
+};
+var _default = exports.default = (0, _withTooltip.default)(Label);

package/lib/inputs/base/helpers.d.ts

@@ -0,0 +1,17 @@
+import { IBaseProps } from './types.js';
+import { TextAlign } from '../../@types/Align.js';
+import 'react';
+import '../../@types/Period.js';
+import '../../@types/PermissionAttr.js';
+import '../../internals/types.js';
+import '../../@types/Position.js';
+
+declare const getInputClass: ({ textAlign, readOnly, readOnlyClass, }: {
+    textAlign?: TextAlign | undefined;
+    readOnly?: boolean | undefined;
+    readOnlyClass?: string | undefined;
+}) => string;
+declare const getInputWrapperClass: (props: IBaseProps) => string;
+declare const getRightElements: (errorMessages: string[], skeletonize: boolean, rightElements?: JSX.Element | JSX.Element[]) => JSX.Element[] | null;
+
+export { getInputClass, getInputWrapperClass, getRightElements };

package/lib/inputs/base/helpers.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRightElements = exports.getInputWrapperClass = exports.getInputClass = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _lodash = _interopRequireDefault(require("lodash"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const getInputClass = _ref => {
+  let {
+    textAlign,
+    readOnly,
+    readOnlyClass
+  } = _ref;
+  return `textinput text-align-${textAlign} ${readOnlyClass} ${readOnly ? ' -readonly' : ''}`;
+};
+exports.getInputClass = getInputClass;
+const getInputWrapperClass = props => {
+  const {
+    inputHasFocus,
+    customClassForWrapper,
+    rounded,
+    errorMessages,
+    disabled
+  } = props;
+  return `inputwrapper ${inputHasFocus && ' -focusable'}
+          ${customClassForWrapper}
+          ${errorMessages && errorMessages.length > 0 && ' -requirederror'}
+          ${rounded && ' -roundedborders'}
+          ${disabled && ' -disabled'}`;
+};
+exports.getInputWrapperClass = getInputWrapperClass;
+const getRightElements = (errorMessages, skeletonize, rightElements) => {
+  let elements = rightElements || [];
+  if (skeletonize) return null;
+  if (!_lodash.default.isArray(elements)) {
+    elements = [elements];
+  }
+  elements = elements.map((element, index) => element && /*#__PURE__*/_react.default.cloneElement(element, {
+    key: `rightelement-${index + 1}`
+  }));
+  if (errorMessages) return elements;
+  return elements;
+};
+exports.getRightElements = getRightElements;