@steroidsjs/core 3.0.0-beta.1 → 3.0.0-beta.100

package/ui/{content/Collapse/CollapseItem.js → typography/Text/Text.js}

@@ -12,11 +12,11 @@ var __assign = (this && this.__assign) || function () {
 };
 exports.__esModule = true;
 var hooks_1 = require("../../../hooks");
-function CollapseItem(props) {
-    var components = hooks_1.useComponents();
-    return components.ui.renderView(props.view || 'content.CollapseItemView', __assign({}, props));
+function Text(props) {
+    var components = (0, hooks_1.useComponents)();
+    return components.ui.renderView(props.view || 'typography.TextView', __assign({}, props));
 }
-CollapseItem.defaultProps = {
-    title: 'Collapse'
+Text.defaultProps = {
+    type: 'body'
 };
-exports["default"] = CollapseItem;
+exports["default"] = Text;

package/ui/typography/Text/index.d.ts

@@ -0,0 +1,2 @@
+import Text from './Text';
+export default Text;

package/ui/typography/Text/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var Text_1 = __importDefault(require("./Text"));
+exports["default"] = Text_1["default"];

package/ui/typography/Title/Title.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+/**
+* Title
+*
+* Компонент предназначен для вывода заголовков, предоставляет возможность для настройки, цвета, типа и тэга.
+*/
+export interface ITitleProps extends IUiComponent {
+    /**
+    * Дочерние элементы
+    */
+    children?: React.ReactNode;
+    /**
+     * Тип заголовка
+     * @example 'h1'
+     */
+    type?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'subtitle' | string;
+    /** HTML тег
+    * @example 'h2'
+    */
+    tag?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+    /** Текст заголовка
+     * @example 'Simple text'
+     */
+    content?: string;
+    /**
+     * Цвет заголовка
+     * @example 'primary'
+     */
+    color?: ColorName;
+}
+export type ITitleViewProps = ITitleProps;
+declare function Title(props: ITitleProps): JSX.Element;
+declare namespace Title {
+    var defaultProps: {
+        type: string;
+    };
+}
+export default Title;

package/ui/typography/Title/Title.js

@@ -0,0 +1,22 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+var hooks_1 = require("../../../hooks");
+function Title(props) {
+    var components = (0, hooks_1.useComponents)();
+    return components.ui.renderView(props.view || 'typography.TitleView', __assign({}, props));
+}
+Title.defaultProps = {
+    type: 'h2'
+};
+exports["default"] = Title;

package/ui/typography/Title/index.d.ts

@@ -0,0 +1,2 @@
+import Title from './Title';
+export default Title;

package/ui/typography/Title/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var Title_1 = __importDefault(require("./Title"));
+exports["default"] = Title_1["default"];

package/ui/typography/index.d.ts

@@ -0,0 +1,3 @@
+import Text from './Text';
+import Title from './Title';
+export { Text, Title, };

package/ui/typography/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.Title = exports.Text = void 0;
+var Text_1 = __importDefault(require("./Text"));
+exports.Text = Text_1["default"];
+var Title_1 = __importDefault(require("./Title"));
+exports.Title = Title_1["default"];

package/utils/calculateComponentAbsolutePosition.d.ts

@@ -0,0 +1,6 @@
+import { IComponentArrowPosition, IComponentStylePosition } from '../hooks/useAbsolutePositioning';
+export default function calculateComponentAbsolutePosition(gap: any, position: any, parentRef: any, componentSize: any, arrowSize?: any, hasAutoPositioning?: boolean): {
+    style: IComponentStylePosition;
+    position: any;
+    arrowPosition: IComponentArrowPosition;
+};

package/{ui/layout/Tooltip/calculate.js → utils/calculateComponentAbsolutePosition.js}

@@ -1,6 +1,12 @@
 "use strict";
 exports.__esModule = true;
-function calculate(gap, position, parentRef, tooltipSize, arrowSize) {
+var useAbsolutePositioning_1 = require("../hooks/useAbsolutePositioning");
+function calculateComponentAbsolutePosition(gap, position, parentRef, componentSize, arrowSize, hasAutoPositioning) {
+    if (arrowSize === void 0) { arrowSize = null; }
+    if (hasAutoPositioning === void 0) { hasAutoPositioning = true; }
+    if (process.env.IS_SSR) {
+        return null;
+    }
     var style = { left: null, right: null, top: null };
     var arrowPosition = null;
     var _a = parentRef.getBoundingClientRect(), top = _a.top, right = _a.right, left = _a.left, width = _a.width, height = _a.height;
@@ -8,54 +14,57 @@ function calculate(gap, position, parentRef, tooltipSize, arrowSize) {
     parentDimensions.top += window.scrollY;
     // eslint-disable-next-line default-case
     switch (position) {
-        case 'top':
-        case 'topLeft':
-        case 'topRight':
+        case useAbsolutePositioning_1.Position.TOP:
+        case useAbsolutePositioning_1.Position.TOP_LEFT:
+        case useAbsolutePositioning_1.Position.TOP_RIGHT:
             // Проверка - выходит ли tooltip за верхний край страницы?
             // Если да - меняем позицию на bottom
-            if ((parentDimensions.top - window.scrollY) <= Math.round(tooltipSize.height + gap)) {
+            if (hasAutoPositioning
+                && ((parentDimensions.top - window.scrollY) <= Math.round(componentSize.height + gap))) {
                 style.top = parentDimensions.top + parentDimensions.height;
-                position = position.replace('top', 'bottom');
+                position = position.replace(useAbsolutePositioning_1.Position.TOP, useAbsolutePositioning_1.Position.BOTTOM);
             }
             else {
-                style.top = parentDimensions.top - tooltipSize.height;
+                style.top = parentDimensions.top - componentSize.height;
             }
             break;
-        case 'bottom':
-        case 'bottomLeft':
-        case 'bottomRight':
+        case useAbsolutePositioning_1.Position.BOTTOM:
+        case useAbsolutePositioning_1.Position.BOTTOM_LEFT:
+        case useAbsolutePositioning_1.Position.BOTTOM_RIGHT:
             /// Проверка - выходит ли tooltip за нижний край страницы?
             // Если да - меняем позицию на top
-            if ((window.innerHeight - (parentDimensions.top + parentDimensions.height - window.scrollY))
-                <= Math.round(tooltipSize.height + gap)) {
-                style.top = parentDimensions.top - tooltipSize.height;
-                position = position.replace('bottom', 'top');
+            if (hasAutoPositioning
+                && ((window.innerHeight - (parentDimensions.top + parentDimensions.height - window.scrollY))
+                    <= Math.round(componentSize.height + gap))) {
+                style.top = parentDimensions.top - componentSize.height;
+                position = position.replace(useAbsolutePositioning_1.Position.BOTTOM, useAbsolutePositioning_1.Position.TOP);
             }
             else {
                 style.top = parentDimensions.top + parentDimensions.height;
             }
             break;
-        case 'left':
-        case 'leftTop':
-        case 'leftBottom':
+        case useAbsolutePositioning_1.Position.LEFT:
+        case useAbsolutePositioning_1.Position.LEFT_TOP:
+        case useAbsolutePositioning_1.Position.LEFT_BOTTOM:
             // Проверка - выходит ли tooltip за левый край страницы?
             // Если да - меняем позицию на right
-            if (parentDimensions.left <= Math.round(tooltipSize.width + gap)) {
+            if (hasAutoPositioning && (parentDimensions.left <= Math.round(componentSize.width + gap))) {
                 style.left = parentDimensions.right;
-                position = position.replace('left', 'right');
+                position = position.replace(useAbsolutePositioning_1.Position.LEFT, useAbsolutePositioning_1.Position.RIGHT);
             }
             else {
-                style.left = parentDimensions.left - tooltipSize.width;
+                style.left = parentDimensions.left - componentSize.width;
             }
             break;
-        case 'right':
-        case 'rightTop':
-        case 'rightBottom':
+        case useAbsolutePositioning_1.Position.RIGHT:
+        case useAbsolutePositioning_1.Position.RIGHT_TOP:
+        case useAbsolutePositioning_1.Position.RIGHT_BOTTOM:
             // Проверка - выходит ли tooltip за правый край страницы?
             // Если да - меняем позицию на left
-            if (document.body.clientWidth - parentDimensions.right <= Math.round(tooltipSize.width + gap)) {
-                style.left = parentDimensions.left - tooltipSize.width;
-                position = position.replace('right', 'left');
+            if (hasAutoPositioning
+                && (document.body.clientWidth - parentDimensions.right <= Math.round(componentSize.width + gap))) {
+                style.left = parentDimensions.left - componentSize.width;
+                position = position.replace(useAbsolutePositioning_1.Position.RIGHT, useAbsolutePositioning_1.Position.LEFT);
             }
             else {
                 style.left = parentDimensions.right;
@@ -64,45 +73,45 @@ function calculate(gap, position, parentRef, tooltipSize, arrowSize) {
     }
     // eslint-disable-next-line default-case
     switch (position) {
-        case 'top':
-        case 'bottom':
+        case useAbsolutePositioning_1.Position.TOP:
+        case useAbsolutePositioning_1.Position.BOTTOM:
             // Выравнивание по середине
-            style.left = (parentDimensions.left + (parentDimensions.width / 2)) - (tooltipSize.width / 2);
+            style.left = (parentDimensions.left + (parentDimensions.width / 2)) - (componentSize.width / 2);
             break;
-        case 'topLeft':
-        case 'bottomLeft':
+        case useAbsolutePositioning_1.Position.TOP_LEFT:
+        case useAbsolutePositioning_1.Position.BOTTOM_LEFT:
             // Ширина tooltip больше родителя - стрелка на середину родителя
             style.left = parentDimensions.left;
-            if (parentDimensions.width < tooltipSize.width) {
+            if (arrowSize && (parentDimensions.width < componentSize.width)) {
                 arrowPosition = { left: parentDimensions.width / 2 };
             }
             break;
-        case 'topRight':
-        case 'bottomRight':
+        case useAbsolutePositioning_1.Position.TOP_RIGHT:
+        case useAbsolutePositioning_1.Position.BOTTOM_RIGHT:
             // Ширина tooltip больше родителя - стрелка на середину родителя
-            style.right = document.body.clientWidth - parentDimensions.right;
-            if (parentDimensions.width < tooltipSize.width) {
+            style.left = parentDimensions.right - componentSize.width;
+            if (arrowSize && (parentDimensions.width < componentSize.width)) {
                 arrowPosition = {
                     left: null,
                     right: (parentDimensions.width / 2) - (arrowSize.width / 2)
                 };
             }
             break;
-        case 'left':
-        case 'right':
-            style.top = (parentDimensions.top + (parentDimensions.height / 2)) - (tooltipSize.height / 2);
+        case useAbsolutePositioning_1.Position.LEFT:
+        case useAbsolutePositioning_1.Position.RIGHT:
+            style.top = (parentDimensions.top + (parentDimensions.height / 2)) - (componentSize.height / 2);
             break;
-        case 'leftTop':
-        case 'rightTop':
+        case useAbsolutePositioning_1.Position.LEFT_TOP:
+        case useAbsolutePositioning_1.Position.RIGHT_TOP:
             style.top = parentDimensions.top;
-            if (parentDimensions.height < (tooltipSize.height)) {
+            if (arrowSize && (parentDimensions.height < componentSize.height)) {
                 arrowPosition = { top: parentDimensions.height / 2 };
             }
             break;
-        case 'leftBottom':
-        case 'rightBottom':
-            style.top = parentDimensions.top + parentDimensions.height - tooltipSize.height;
-            if (parentDimensions.height < tooltipSize.height) {
+        case useAbsolutePositioning_1.Position.LEFT_BOTTOM:
+        case useAbsolutePositioning_1.Position.RIGHT_BOTTOM:
+            style.top = parentDimensions.top + parentDimensions.height - componentSize.height;
+            if (arrowSize && (parentDimensions.height < componentSize.height)) {
                 arrowPosition = {
                     bottom: (parentDimensions.height / 2) - (arrowSize.height / 2)
                 };
@@ -112,20 +121,20 @@ function calculate(gap, position, parentRef, tooltipSize, arrowSize) {
     // Проверка - при позиционировании top/bottom tooltip не выходит за пределы страницы по горизонтали
     if (position.includes('top') || position.includes('bottom')) {
         if (!position.includes('Left')
-            && (style.left < 0 || parentDimensions.left <= Math.round((tooltipSize.width - parentDimensions.width) + gap))) {
+            && (style.left < 0 || parentDimensions.left <= Math.round((componentSize.width - parentDimensions.width) + gap))) {
             style.right = null;
             position = position.replace('Right', 'Left');
             // Если ширина tooltip больше ширины родителя - выставить стрелку на середину родителя
-            if (parentDimensions.left < tooltipSize.width) {
+            if (parentDimensions.left < componentSize.width) {
                 arrowPosition = { left: parentDimensions.width / 2 };
             }
             style.left = parentDimensions.left;
         }
-        if (!position.includes('Right')
+        else if (!position.includes('Right')
             && (document.body.clientWidth - parentDimensions.right
-                <= Math.round((tooltipSize.width - parentDimensions.width) + gap))) {
+                <= Math.round((componentSize.width - parentDimensions.width) + gap))) {
             position = position.replace('Left', 'Right');
-            if (parentDimensions.width < tooltipSize.width) {
+            if (arrowSize && (parentDimensions.width < componentSize.width)) {
                 arrowPosition = {
                     left: null,
                     right: (parentDimensions.width / 2) - (arrowSize.width / 2)
@@ -138,25 +147,25 @@ function calculate(gap, position, parentRef, tooltipSize, arrowSize) {
     // Проверка - при позиционировании left/right tooltip не выходит за пределы страницы по вертикали
     if (position.includes('left') || position.includes('right')) {
         if (!position.includes('Top')
-            && parentDimensions.top - window.scrollY <= Math.round((tooltipSize.height - parentDimensions.height) + gap)) {
+            && parentDimensions.top - window.scrollY <= Math.round((componentSize.height - parentDimensions.height) + gap)) {
             position = position.replace('Bottom', 'Top');
-            if (parentDimensions.height < tooltipSize.height) {
+            if (parentDimensions.height < componentSize.height) {
                 arrowPosition = { top: parentDimensions.height / 2 };
             }
             style.top = parentDimensions.top;
         }
-        if (!position.includes('Bottom')
+        else if (!position.includes('Bottom')
             && (window.innerHeight - (parentDimensions.top + parentDimensions.height - window.scrollY)
-                <= Math.round((tooltipSize.height - parentDimensions.height) + gap))) {
+                <= Math.round((componentSize.height - parentDimensions.height) + gap))) {
             position = position.replace('Top', 'Bottom');
-            if (parentDimensions.height < tooltipSize.height) {
+            if (arrowSize && (parentDimensions.height < componentSize.height)) {
                 arrowPosition = {
                     bottom: (parentDimensions.height / 2) - (arrowSize.height / 2)
                 };
             }
-            style.top = parentDimensions.top + parentDimensions.height - tooltipSize.height;
+            style.top = parentDimensions.top + parentDimensions.height - componentSize.height;
         }
     }
     return { style: style, position: position, arrowPosition: arrowPosition };
 }
-exports["default"] = calculate;
+exports["default"] = calculateComponentAbsolutePosition;

package/utils/calendar.d.ts

@@ -1,4 +1,4 @@
-export declare const convertDate: (date: string | Date, fromFormats: string | string[], toFormat?: string, utc?: boolean, dateInUtc?: boolean) => any;
+export declare const convertDate: (date: string | Date, fromFormats: string | string[], toFormat?: string, isUtc?: boolean, dateInUtc?: boolean) => any;
 /**
  * Регулярка проверяет соответствие введенной строки формату 'hh:mm'
  * Максимальная величина - 23:59

package/utils/calendar.js

@@ -4,42 +4,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 exports.__esModule = true;
 exports.convertDate = void 0;
-var moment_1 = __importDefault(require("moment"));
-var convertDate = function (date, fromFormats, toFormat, utc, dateInUtc) {
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable import/prefer-default-export */
+var dayjs_1 = __importDefault(require("dayjs"));
+var utc_1 = __importDefault(require("dayjs/plugin/utc"));
+var customParseFormat_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
+dayjs_1["default"].extend(utc_1["default"]);
+dayjs_1["default"].extend(customParseFormat_1["default"]);
+var convertDate = function (date, fromFormats, toFormat, isUtc, dateInUtc) {
     if (toFormat === void 0) { toFormat = null; }
-    if (utc === void 0) { utc = false; }
+    if (isUtc === void 0) { isUtc = false; }
     if (dateInUtc === void 0) { dateInUtc = false; }
     if (!date) {
         return null;
     }
-    var momentDate;
+    var dayjsDate;
     if (typeof date === 'string' && fromFormats) {
         var validFormat = [].concat(fromFormats || []).find(function (format) { return (date
             && date.length === format.length
-            && moment_1["default"](date, format).isValid()); });
+            && (0, dayjs_1["default"])(date, format).isValid()); });
         if (!validFormat) {
             return null;
         }
         if (dateInUtc) {
-            momentDate = moment_1["default"].utc(date, validFormat);
+            dayjsDate = (0, dayjs_1["default"])(date, validFormat).utc(true);
         }
         else {
-            momentDate = moment_1["default"](date, validFormat);
+            dayjsDate = (0, dayjs_1["default"])(date, validFormat);
         }
     }
     else if (date instanceof Date) {
-        momentDate = moment_1["default"](date);
+        dayjsDate = (0, dayjs_1["default"])(date);
     }
-    if (!momentDate) {
+    if (!dayjsDate) {
         return null;
     }
-    if (utc) {
-        momentDate = momentDate.utc();
+    if (isUtc) {
+        dayjsDate = dayjsDate.utc();
     }
-    else {
-        momentDate = momentDate.local();
-    }
-    return toFormat ? momentDate.format(toFormat) : momentDate.toDate();
+    return toFormat ? dayjsDate.format(toFormat) : dayjsDate.toDate();
 };
 exports.convertDate = convertDate;
 /**

package/utils/collection.js

@@ -7,7 +7,7 @@ exports.indexBy = void 0;
 var isArray_1 = __importDefault(require("lodash-es/isArray"));
 // eslint-disable-next-line import/prefer-default-export
 var indexBy = function (collection, key) {
-    if (!isArray_1["default"](collection)) {
+    if (!(0, isArray_1["default"])(collection)) {
         return collection;
     }
     var result = {};

package/utils/data.d.ts

@@ -6,4 +6,5 @@
 export declare const normalizeItems: (items: any) => any;
 export declare const checkCondition: (item: any, condition: any) => any;
 export declare const filterItems: (items: Array<any>, condition: any) => any[];
+export declare const shouldUpdateSingle: (a: any, b: any) => boolean;
 export declare const shouldUpdate: (objA: any, objB: any, deepPaths?: any) => boolean;

package/utils/data.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 exports.__esModule = true;
-exports.shouldUpdate = exports.filterItems = exports.checkCondition = exports.normalizeItems = void 0;
+exports.shouldUpdate = exports.shouldUpdateSingle = exports.filterItems = exports.checkCondition = exports.normalizeItems = void 0;
 var uniqBy_1 = __importDefault(require("lodash-es/uniqBy"));
 var isString_1 = __importDefault(require("lodash-es/isString"));
 var isArray_1 = __importDefault(require("lodash-es/isArray"));
@@ -31,11 +31,11 @@ var every_1 = __importDefault(require("lodash-es/every"));
  */
 var normalizeItems = function (items) {
     // Array
-    if (isArray_1["default"](items)) {
+    if ((0, isArray_1["default"])(items)) {
         // List of strings/numbers
-        if (some_1["default"](items, function (item) { return isString_1["default"](item) || isInteger_1["default"](item); })) {
+        if ((0, some_1["default"])(items, function (item) { return (0, isString_1["default"])(item) || (0, isInteger_1["default"])(item); })) {
             return items.map(function (item) {
-                if (isString_1["default"](item) || isInteger_1["default"](item)) {
+                if ((0, isString_1["default"])(item) || (0, isInteger_1["default"])(item)) {
                     return {
                         id: item,
                         label: item
@@ -45,13 +45,13 @@ var normalizeItems = function (items) {
             });
         }
         // Labels as ids
-        if (some_1["default"](items, function (item) { return !has_1["default"](item, 'id'); })) {
-            return uniqBy_1["default"](items.map(function (item) { return (__assign({ id: item.label }, item)); }), 'label');
+        if ((0, some_1["default"])(items, function (item) { return !(0, has_1["default"])(item, 'id'); })) {
+            return (0, uniqBy_1["default"])(items.map(function (item) { return (__assign({ id: item.label }, item)); }), 'label');
         }
         return items;
     }
     // Enum
-    if (isObject_1["default"](items) && isFunction_1["default"](items.getLabels)) {
+    if ((0, isObject_1["default"])(items) && (0, isFunction_1["default"])(items.getLabels)) {
         var labels_1 = items.getLabels();
         return Object.keys(labels_1).map(function (id) { return ({
             id: id,
@@ -62,19 +62,19 @@ var normalizeItems = function (items) {
 };
 exports.normalizeItems = normalizeItems;
 var checkCondition = function (item, condition) {
-    if (isObject_1["default"](condition) && !isArray_1["default"](condition)) {
-        return every_1["default"](Object.keys(condition), function (key) {
+    if ((0, isObject_1["default"])(condition) && !(0, isArray_1["default"])(condition)) {
+        return (0, every_1["default"])(Object.keys(condition), function (key) {
             var value = condition[key];
-            var operator = isString_1["default"](value) ? 'like' : '=';
-            return exports.checkCondition(item, [operator, key, value]);
+            var operator = (0, isString_1["default"])(value) ? 'like' : '=';
+            return (0, exports.checkCondition)(item, [operator, key, value]);
         });
     }
-    if (isArray_1["default"](condition) && condition.length > 1) {
+    if ((0, isArray_1["default"])(condition) && condition.length > 1) {
         var operator = condition[0].toLowerCase();
         // ['not', {role: 'admin'}]
         if (operator.indexOf('not') === 0) {
             var newOperator = operator.replace(/^not\s+/, '');
-            return !exports.checkCondition(item, [newOperator].concat(condition.slice(1)));
+            return !(0, exports.checkCondition)(item, [newOperator].concat(condition.slice(1)));
         }
         var key = condition[1];
         var value = condition[2];
@@ -93,37 +93,38 @@ var checkCondition = function (item, condition) {
                 return item[key] <= value;
             case 'and': // ['and', {isActive: true}, ['=', 'name', 'Ivan']]
             case '&&':
-                return every_1["default"](condition.slice(1), function (subCondition) { return exports.checkCondition(item, subCondition); });
+                return (0, every_1["default"])(condition.slice(1), function (subCondition) { return (0, exports.checkCondition)(item, subCondition); });
             case 'or': // ['or', {isAdmin: true}, ['=', 'name', 'Ivan']]
             case '||':
-                return some_1["default"](condition.slice(1), function (subCondition) { return exports.checkCondition(item, subCondition); });
+                return (0, some_1["default"])(condition.slice(1), function (subCondition) { return (0, exports.checkCondition)(item, subCondition); });
             case 'like': // ['like', 'name', 'alex']
-                return isString_1["default"](item[key]) && item[key].toLowerCase().indexOf(value.toLowerCase()) !== -1;
+                return (0, isString_1["default"])(item[key]) && item[key].toLowerCase().indexOf(value.toLowerCase()) !== -1;
             case 'between': // ['between', 'size', 5, 10]
                 return condition[2] <= value && value <= condition[3];
             case 'in': // ['in', 'ids', [5, 6, 10]]
-                return isArray_1["default"](item[key]) && item[key].includes(value);
+                return (0, isArray_1["default"])(item[key]) && item[key].includes(value);
             default:
                 throw Error('Wrong operator: ' + operator);
         }
     }
-    if (isFunction_1["default"](condition)) {
+    if ((0, isFunction_1["default"])(condition)) {
         return !!condition(item);
     }
     return true;
 };
 exports.checkCondition = checkCondition;
-var filterItems = function (items, condition) { return items.filter(function (item) { return exports.checkCondition(item, condition); }); };
+var filterItems = function (items, condition) { return items.filter(function (item) { return (0, exports.checkCondition)(item, condition); }); };
 exports.filterItems = filterItems;
 var shouldUpdateSingle = function (a, b) {
-    if (isFunction_1["default"](a) && isFunction_1["default"](b)) {
+    if ((0, isFunction_1["default"])(a) && (0, isFunction_1["default"])(b)) {
         return false;
     }
     return a !== b;
 };
+exports.shouldUpdateSingle = shouldUpdateSingle;
 var shouldUpdate = function (objA, objB, deepPaths) {
     if (deepPaths === void 0) { deepPaths = null; }
-    if (isObject_1["default"](objA) && isObject_1["default"](objB)) {
+    if ((0, isObject_1["default"])(objA) && (0, isObject_1["default"])(objB)) {
         var keysA = Object.keys(objA);
         var keysB = Object.keys(objB);
         if (keysA.length !== keysB.length) {
@@ -131,7 +132,7 @@ var shouldUpdate = function (objA, objB, deepPaths) {
         }
         // Convert deep paths to array of arrays
         if (deepPaths) {
-            deepPaths = deepPaths.map(function (p) { return isString_1["default"](p) ? p.split('.') : p; });
+            deepPaths = deepPaths.map(function (p) { return (0, isString_1["default"])(p) ? p.split('.') : p; });
         }
         var _loop_1 = function (i) {
             var key = keysA[i];
@@ -140,8 +141,8 @@ var shouldUpdate = function (objA, objB, deepPaths) {
                 deepPath = deepPaths.find(function (p) { return p[0] === key; }) || null;
             }
             var hasChanges = deepPath
-                ? exports.shouldUpdate(objA[key], objB[key], deepPath)
-                : shouldUpdateSingle(objA[key], objB[key]);
+                ? (0, exports.shouldUpdate)(objA[key], objB[key], deepPath)
+                : (0, exports.shouldUpdateSingle)(objA[key], objB[key]);
             if (hasChanges) {
                 console.log(0, 'shouldUpdate changed key:', key, objA[key], objB[key]);
                 return { value: true };
@@ -154,6 +155,6 @@ var shouldUpdate = function (objA, objB, deepPaths) {
         }
         return false;
     }
-    return shouldUpdateSingle(objA, objB);
+    return (0, exports.shouldUpdateSingle)(objA, objB);
 };
 exports.shouldUpdate = shouldUpdate;

package/utils/form.d.ts

@@ -1,17 +1,15 @@
 /// <reference types="react" />
 export declare const setInWithPath: (state: any, value: any, path: string[], pathIndex?: number) => any;
-export declare const normalizeLayout: (layout: any) => any;
-export declare const mergeLayoutProp: (layout1: any, layout2: any) => any;
 export declare const cleanEmptyObject: (object: any) => any;
 export declare const providers: {
     redux: {
         useForm: (formId: any, initialValues: any) => any;
         useField: (formId: any, name: any, isList: any) => {
-            setValue: (value: any) => any;
+            setValue: (value: any) => void;
             errors: any;
             value: any;
         };
-        useDispatch: () => any;
+        useDispatch: () => import("react").Dispatch<any>;
         select: (formId: any, selector: any) => any;
     };
     reducer: {