linear-react-components-ui 0.4.77-beta.9 → 1.0.0-rc.2

package/lib/inputs/select/types.d.ts

@@ -0,0 +1,97 @@
+import { ReactNode } from 'react';
+import { DataCombo } from '../../@types/DataCombo.js';
+import { PermissionAttr } from '../../@types/PermissionAttr.js';
+import { CustomInputEvent } from '../base/types.js';
+import '../../@types/Period.js';
+
+interface ISelectFieldProps {
+    multiple?: boolean;
+    gridLayout?: string;
+    descriptionKey?: string;
+    idKey?: string;
+    dataSource?: DataCombo[];
+    showClearButton?: boolean;
+    searchOnDropdown?: boolean;
+    searchNotFoundText?: string;
+    inputText?: string | '';
+    striped?: boolean | false;
+    readOnly?: boolean;
+    onChange?: () => void;
+    undigitable?: boolean;
+    rounded?: boolean;
+    selectFirstOnEnter?: boolean;
+    remoteSearch?: boolean;
+    onSearch?: () => void;
+    onBlur?: () => void;
+    openDropdownOnFocus?: boolean;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+}
+interface ISimpleSelectProps {
+    idKey: string;
+    descriptionKey: string;
+    dataSource?: DataCombo[];
+    id?: string;
+    label?: string;
+    placeHolder?: string;
+    hint?: string;
+    textAlign?: string;
+    errorMessages?: string[];
+    showClearButton?: boolean;
+    searchOnDropdown?: boolean;
+    searchNotFoundText?: string;
+    onChange?: (e: CustomInputEvent) => void;
+    value?: string | number | boolean | number[];
+    undigitable?: boolean;
+    name?: string;
+    selectFirstOnEnter?: boolean;
+    openDropdownOnFocus?: boolean;
+    onSearch?: (value: string) => void;
+    remoteSearch?: boolean;
+    onBlur?: (e: CustomInputEvent) => void;
+    onClick?: () => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    gridLayout?: string;
+    inputText?: string;
+    striped?: boolean | false;
+    permissionAttr?: PermissionAttr;
+    maxLength?: number;
+    dropdownMaxHeight?: number;
+    multiple?: boolean;
+    rounded?: boolean;
+    required?: boolean;
+    autoFocus?: boolean;
+    onFocus?: () => void;
+}
+interface IMultipleSelectProps {
+    descriptionKey: string;
+    idKey: string;
+    dataSource: DataCombo[];
+    searchNotFoundText?: string;
+    searchOnDropdown?: boolean;
+    value?: number[] | string[];
+    showClearButton?: boolean;
+    readOnly?: boolean;
+    onSearch?: (value?: string) => void;
+    onSelect?: (data?: string | string[]) => DataCombo;
+    remoteSearch?: boolean;
+    onBlur?: (e: CustomInputEvent) => void;
+    handlerClear?: () => void;
+    disabled?: boolean;
+    gridLayout?: string;
+}
+interface ISelectedsMultipleProps {
+    idKey: string;
+    descriptionKey: string;
+    currents: DataCombo[];
+    handleOnUnselect: (id: string) => void;
+}
+interface IAdvancedFilterProps {
+    onStateChange?: (bol?: boolean) => void;
+    headerTitle?: string;
+    content?: ReactNode | ReactNode[];
+}
+
+export { IAdvancedFilterProps, IMultipleSelectProps, ISelectFieldProps, ISelectedsMultipleProps, ISimpleSelectProps };

package/lib/inputs/select/types.js

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

package/lib/inputs/text/index.d.ts

@@ -0,0 +1,9 @@
+import { ITextField } from './types.js';
+import '../../@types/Period.js';
+import '../../@types/PermissionAttr.js';
+import '../base/types.js';
+import 'react';
+
+declare const TextField: (props: ITextField) => JSX.Element;
+
+export { TextField as default };

package/lib/inputs/text/index.js

@@ -3,17 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
+exports.default = void 0;
 
 var _react = _interopRequireDefault(require("react"));
 
 var _InputTextBase = _interopRequireDefault(require("../base/InputTextBase"));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+// eslint-disable-next-line import/no-named-as-default
 var TextField = function TextField(props) {
-  return /*#__PURE__*/_react["default"].createElement(_InputTextBase["default"], props);
+  return /*#__PURE__*/_react.default.createElement(_InputTextBase.default, props);
 };
 
 var _default = TextField;
-exports["default"] = _default;
+exports.default = _default;

package/lib/inputs/text/types.d.ts

@@ -0,0 +1,22 @@
+import { Period } from '../../@types/Period.js';
+import { PermissionAttr } from '../../@types/PermissionAttr.js';
+import { CustomInputEvent } from '../base/types.js';
+import 'react';
+
+interface ITextField {
+    value?: string | string[];
+    required?: boolean;
+    name?: string;
+    label?: string | string[];
+    onChange?: (e?: CustomInputEvent, maskValue?: string, date?: {
+        initial: string;
+        final: string;
+    }, period?: Period) => void;
+    leftElements?: JSX.Element | JSX.Element[];
+    rightElements?: JSX.Element | JSX.Element[];
+    permissionAttr?: PermissionAttr;
+    textAlign?: string;
+    gridLayout?: string;
+}
+
+export { ITextField };

package/lib/inputs/text/types.js

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

package/lib/inputs/textarea/index.d.ts

@@ -0,0 +1,5 @@
+import { ITextAreaProps } from './types.js';
+
+declare const TextArea: (props: ITextAreaProps) => JSX.Element;
+
+export { TextArea as default };

package/lib/inputs/textarea/index.js

@@ -3,39 +3,29 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
+exports.default = void 0;
 
 var _react = _interopRequireDefault(require("react"));
 
-var _propTypes = _interopRequireDefault(require("prop-types"));
-
 var _InputTextBase = _interopRequireDefault(require("../base/InputTextBase"));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
 var TextArea = function TextArea(props) {
   var rows = props.rows,
       cols = props.cols,
-      customClass = props.customClass;
-  return /*#__PURE__*/_react["default"].createElement(_InputTextBase["default"], _extends({}, props, {
-    type: "textarea",
+      customClass = props.customClass,
+      _props$type = props.type,
+      type = _props$type === void 0 ? 'textarea' : _props$type;
+  return /*#__PURE__*/_react.default.createElement(_InputTextBase.default, _extends({}, props, {
     rows: rows,
+    type: type,
     cols: cols,
     customClass: "textarea-container ".concat(customClass)
   }));
 };
 
-TextArea.propTypes = {
-  rows: _propTypes["default"].string,
-  cols: _propTypes["default"].string,
-  customClass: _propTypes["default"].string
-};
-TextArea.defaultProps = {
-  rows: '',
-  cols: '',
-  customClass: ''
-};
 var _default = TextArea;
-exports["default"] = _default;
+exports.default = _default;

package/lib/inputs/textarea/types.d.ts

@@ -0,0 +1,8 @@
+interface ITextAreaProps {
+    rows?: number;
+    cols?: number;
+    customClass?: string;
+    type?: string;
+}
+
+export { ITextAreaProps };

package/lib/inputs/textarea/types.js

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

package/lib/inputs/types.d.ts

@@ -0,0 +1,146 @@
+import { MouseEvent, MutableRefObject, CSSProperties, ReactNode, KeyboardEvent, ReactElement } from 'react';
+import { PermissionAttr, OnDenied } from '../@types/PermissionAttr.js';
+import { DataCombo } from '../@types/DataCombo.js';
+import { IAdvancedFilterProps } from './select/types.js';
+import { CustomInputEvent } from './base/types.js';
+import '../@types/Period.js';
+
+interface ISearchProps {
+    resetButton?: boolean;
+    onReset?: (event?: CustomInputEvent) => void;
+    onChange?: (event?: CustomInputEvent) => void;
+    onClick?: (event: MouseEvent<HTMLButtonElement>) => void;
+    textAlign?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    value?: string;
+    placeHolder?: string;
+    permissionAttr?: PermissionAttr;
+    advancedFilterProps?: IAdvancedFilterProps;
+    rounded?: boolean;
+    inputRef?: MutableRefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+    style?: CSSProperties;
+}
+interface IDropdownProps {
+    children: ReactNode | ReactNode[];
+    dropdownRef: (el: HTMLDivElement) => void;
+    topPosition: number | string;
+    leftPosition: number | string;
+    width: number | string;
+}
+interface IInputHOCProps {
+    value?: string | string[];
+    required?: boolean;
+    gridLayout?: string;
+    visible?: boolean;
+    rows?: number;
+    cols?: number;
+    type?: string;
+}
+interface IMaskHOCProps {
+    label?: string;
+    value?: string;
+    unmask?: boolean;
+    name?: string;
+    commit?: () => void;
+    onChange?: (event: CustomInputEvent, maskValue?: string, date?: string | {
+        initial: string;
+        final: string;
+    }) => void;
+    onFocus?: (e: CustomInputEvent) => void;
+    onComplete?: (e: CustomInputEvent, maskValue?: string, date?: string) => void;
+    inputRef?: MutableRefObject<HTMLInputElement | HTMLTextAreaElement | null> | ((ref: HTMLInputElement | HTMLTextAreaElement | null) => void);
+    placeholderChar?: string;
+    lazy?: boolean;
+    definitions?: object;
+    groups?: object;
+    pattern?: string;
+    format?: () => void;
+    parse?: () => void;
+    radix?: string;
+    thousandsSeparator?: string;
+    mapToRadix?: string[];
+    scale?: number;
+    signed?: boolean;
+    normalizeZeros?: boolean;
+    padFractionalZeros?: boolean;
+    min?: number;
+    max?: number;
+    dispatch?: () => void;
+    permissionAttr?: PermissionAttr;
+    handlerSetOnDenied?: (onDeniedValue: OnDenied) => void;
+    isNumeric?: boolean;
+    required?: boolean;
+    onKeyDown?: (e: KeyboardEvent<Element>) => void;
+    rightElements?: JSX.Element | JSX.Element[];
+    labelUppercase?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+    gridLayout?: string;
+    placeHolder?: string;
+    customClass?: string;
+    customClassForInputContent?: string;
+    customClassForLabel?: string;
+    textAlign?: string;
+    onBlur?: (e: {
+        target: {
+            value: string;
+            name?: string;
+        };
+    }) => void;
+    leftElements?: JSX.Element | JSX.Element[];
+    rounded?: boolean;
+    errorMessages?: string[];
+    skeletonize?: boolean;
+    mask?: string | NumberConstructor;
+}
+interface IDropdownSelectProps {
+    idKey: string;
+    descriptionKey: string;
+    dropdownWidth: number;
+    showClearButton?: boolean;
+    handleOnSelect: (item?: DataCombo) => void;
+    handleOnFilter: (value: string) => void;
+    handleOnKeydown: (e: KeyboardEvent<Element>) => void;
+    handleOnBlur: (item: DataCombo) => void;
+    handleOnFocus: () => void;
+    opened: boolean;
+    dropdownRef: MutableRefObject<HTMLDivElement | null>;
+    dataCombo: DataCombo[];
+    searchOnDropdown?: boolean;
+    searchNotFoundText?: string;
+    imgSrcKey?: string;
+    selected?: {
+        [key: string]: number;
+    };
+    currents?: DataCombo[];
+    imageAlign?: 'left' | 'right';
+    striped?: boolean;
+    gridWrapperStyle?: {
+        paddingLeft: string;
+        paddingRight: string;
+    };
+    selectFieldRef?: MutableRefObject<HTMLInputElement | null>;
+    dropdownMaxHeight?: number;
+    inputValue?: string;
+    align?: 'left' | 'right';
+}
+interface IActionButtonsSelectProps {
+    handleClear: () => void;
+    handleOpenClose: () => void;
+    dropDownOpened: boolean;
+    showClearButton?: boolean;
+    disabled?: boolean;
+}
+interface IButtonsProps {
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+    icon: ReactElement;
+    key: string;
+    boxShadow: boolean;
+    readOnly?: boolean;
+    style: CSSProperties;
+    transparent: boolean;
+    disabled?: boolean;
+}
+
+export { IActionButtonsSelectProps, IButtonsProps, IDropdownProps, IDropdownSelectProps, IInputHOCProps, IMaskHOCProps, ISearchProps };

package/lib/inputs/types.js

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

package/lib/internals/colorStyles.d.ts

@@ -0,0 +1,9 @@
+declare const ColorStyles: {
+    PRIMARY: string;
+    SUCCESS: string;
+    DANGER: string;
+    INFO: string;
+    WARNING: string;
+};
+
+export { ColorStyles as default };

package/lib/internals/colorStyles.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
+exports.default = void 0;
 var ColorStyles = {
   PRIMARY: 'primary',
   SUCCESS: 'success',
@@ -12,4 +12,4 @@ var ColorStyles = {
   WARNING: 'warning'
 };
 var _default = ColorStyles;
-exports["default"] = _default;
+exports.default = _default;

package/lib/internals/constants.d.ts

@@ -0,0 +1,11 @@
+declare const keyCodes: {
+    TAB: number;
+    ENTER: number;
+    ARROW_UP: number;
+    ARROW_DOWN: number;
+    BACKSPACE: number;
+    F: number;
+};
+declare const PARA_ENGANAR_O_ESLINT_JA_QUE_TENHO_SO_UMA_CONSTANTE = 1;
+
+export { PARA_ENGANAR_O_ESLINT_JA_QUE_TENHO_SO_UMA_CONSTANTE, keyCodes };

package/lib/internals/types.d.ts

@@ -0,0 +1,21 @@
+import { CSSProperties } from 'react';
+import { OnDenied } from '../@types/PermissionAttr.js';
+import { Position } from '../@types/Position.js';
+
+interface WithTooltipProps {
+    tooltipWidth?: string | number;
+    space?: number;
+    tooltip?: string;
+    tooltipPosition?: Exclude<Position, 'center'>;
+    style?: CSSProperties;
+    handlerSetOnDenied?: (onDeniedValue: OnDenied) => void;
+}
+interface GetDisplayNameParams {
+    displayName?: string;
+    name?: string;
+}
+interface HasToolTipParams {
+    tooltip?: string;
+}
+
+export { GetDisplayNameParams, HasToolTipParams, WithTooltipProps };

package/lib/internals/withTooltip.d.ts

@@ -0,0 +1,11 @@
+import React__default from 'react';
+import { WithTooltipProps } from './types.js';
+import '../@types/PermissionAttr.js';
+import '../@types/Position.js';
+
+declare const withTooltip: <ComponentProps extends WithTooltipProps>(WrappedComponent: React__default.ComponentType<ComponentProps>) => {
+    (props: ComponentProps): JSX.Element;
+    displayName: string;
+};
+
+export { withTooltip as default };

package/lib/internals/withTooltip.js

@@ -1,25 +1,23 @@
 "use strict";
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
+exports.default = void 0;
 
 var _react = _interopRequireWildcard(require("react"));
 
-var _propTypes = _interopRequireDefault(require("prop-types"));
-
 var _tooltip = _interopRequireDefault(require("../tooltip"));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
@@ -40,20 +38,26 @@ var hasTooltip = function hasTooltip(_ref) {
   return tooltip;
 };
 
-var getDisplayName = function getDisplayName(WrappedComponent) {
-  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
+var getDisplayName = function getDisplayName(_ref2) {
+  var displayName = _ref2.displayName,
+      name = _ref2.name;
+  return displayName || name || 'Component';
 };
 
 var withTooltip = function withTooltip(WrappedComponent) {
   var EnhancedComponent = function EnhancedComponent(props) {
     var tooltip = props.tooltip,
-        tooltipWidth = props.tooltipWidth,
-        space = props.space;
-
-    var _useState = (0, _react.useState)(props.tooltipPosition),
+        _props$tooltipWidth = props.tooltipWidth,
+        tooltipWidth = _props$tooltipWidth === void 0 ? 'auto' : _props$tooltipWidth,
+        _props$space = props.space,
+        space = _props$space === void 0 ? 20 : _props$space,
+        _props$tooltipPositio = props.tooltipPosition,
+        tooltipPosition = _props$tooltipPositio === void 0 ? 'bottom' : _props$tooltipPositio;
+
+    var _useState = (0, _react.useState)(tooltipPosition),
         _useState2 = _slicedToArray(_useState, 2),
-        tooltipPosition = _useState2[0],
-        setTooltipPosition = _useState2[1];
+        stateTooltipPosition = _useState2[0],
+        setStateTooltipPosition = _useState2[1];
 
     var _useState3 = (0, _react.useState)(''),
         _useState4 = _slicedToArray(_useState3, 2),
@@ -77,7 +81,7 @@ var withTooltip = function withTooltip(WrappedComponent) {
     var tooltipElement = (0, _react.useRef)(null);
 
     var onMouseOver = function onMouseOver(e) {
-      if (targetElement && targetElement.current && targetElement.current.contains(e.target)) {
+      if (targetElement.current && targetElement.current.contains(e.target)) {
         setShowTooltip(true);
       } else setShowTooltip(false);
     };
@@ -123,10 +127,10 @@ var withTooltip = function withTooltip(WrappedComponent) {
         left = Math.min(left, document.body.clientWidth - tooltipClientWidth - space);
         style += "; left: ".concat(Math.max(space, left), "px");
 
-        switch (tooltipPosition) {
+        switch (stateTooltipPosition) {
           case 'top':
             if (targetDimensions.top < height) {
-              setTooltipPosition('bottom');
+              setStateTooltipPosition('bottom');
             } else {
               style += "; top: ".concat(targetDimensions.top + window.scrollY - height - 5, "px");
             }
@@ -135,7 +139,7 @@ var withTooltip = function withTooltip(WrappedComponent) {
 
           case 'bottom':
             if (window.innerHeight - targetDimensions.bottom < height) {
-              setTooltipPosition('top');
+              setStateTooltipPosition('top');
             } else {
               style += "; top: ".concat(targetDimensions.top + window.scrollY + targetDimensions.height + 5, "px");
             }
@@ -144,7 +148,7 @@ var withTooltip = function withTooltip(WrappedComponent) {
 
           case 'left':
             if (targetDimensions.left < tooltipClientWidth) {
-              setTooltipPosition('right');
+              setStateTooltipPosition('right');
             } else {
               style += "; top: ".concat(targetVerticalCenter + window.scrollY - height / 2, "px");
               style += "; left: ".concat(targetDimensions.left - tooltipClientWidth - 6, "px");
@@ -154,7 +158,7 @@ var withTooltip = function withTooltip(WrappedComponent) {
 
           case 'right':
             if (window.innerWidth - targetDimensions.right < tooltipClientWidth) {
-              setTooltipPosition('left');
+              setStateTooltipPosition('left');
             } else {
               style += "; top: ".concat(targetVerticalCenter + window.scrollY - height / 2, "px");
               style += "; left: ".concat(targetDimensions.left + targetDimensions.width + 5, "px");
@@ -168,18 +172,18 @@ var withTooltip = function withTooltip(WrappedComponent) {
 
         setTooltipStyle(style);
       }
-    }, [tooltipDimensions, tooltipElement.current, targetElement.current, tooltipPosition]);
+    }, [tooltipDimensions, tooltipElement.current, targetElement.current, stateTooltipPosition]);
     (0, _react.useEffect)(function () {
-      setTooltipPosition(props.tooltipPosition);
+      setStateTooltipPosition(tooltipPosition);
     }, [window.scrollY, window.scrollX, window.innerWidth]);
 
     var getTooltip = function getTooltip() {
       if (tooltip) {
-        return /*#__PURE__*/_react["default"].createElement(_tooltip["default"], {
+        return /*#__PURE__*/_react.default.createElement(_tooltip.default, {
           text: tooltip,
           tooltipRef: tooltipElement,
           style: tooltipStyle,
-          className: tooltipPosition,
+          className: stateTooltipPosition,
           tooltipDimensions: tooltipDimensions,
           handlerSetDimensions: setTooltipDimensions
         });
@@ -192,27 +196,15 @@ var withTooltip = function withTooltip(WrappedComponent) {
       if (!targetElement.current) targetElement.current = targetEl;
     };
 
-    if (!hasTooltip(props)) return /*#__PURE__*/_react["default"].createElement(WrappedComponent, props);
-    return /*#__PURE__*/_react["default"].createElement(_react.Fragment, null, /*#__PURE__*/_react["default"].createElement(WrappedComponent, _extends({}, props, {
+    if (!hasTooltip(props)) return /*#__PURE__*/_react.default.createElement(WrappedComponent, props);
+    return /*#__PURE__*/_react.default.createElement(_react.Fragment, null, /*#__PURE__*/_react.default.createElement(WrappedComponent, _extends({}, props, {
       targetRef: getTarget
     })), showTooltip && getTooltip());
   };
 
-  EnhancedComponent.propTypes = {
-    tooltipWidth: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number]),
-    space: _propTypes["default"].number,
-    tooltip: _propTypes["default"].string,
-    tooltipPosition: _propTypes["default"].string
-  };
-  EnhancedComponent.defaultProps = {
-    tooltipWidth: 'auto',
-    space: 20,
-    tooltip: '',
-    tooltipPosition: 'bottom'
-  };
   EnhancedComponent.displayName = "withTooltip(".concat(getDisplayName(WrappedComponent), ")");
   return EnhancedComponent;
 };
 
 var _default = withTooltip;
-exports["default"] = _default;
+exports.default = _default;

package/lib/labelMessages/index.d.ts

@@ -0,0 +1,7 @@
+import { ILabelMessagesProps } from './types.js';
+import 'react';
+import '../@types/LabelStyles.js';
+
+declare const LabelMessages: ({ style, icon, flat, iconName, handlerClosed, square, visible, children, customClass, type, showCloseButton }: ILabelMessagesProps) => JSX.Element | null;
+
+export { LabelMessages as default };