@reltio/components 1.4.1988 → 1.4.1990

package/esm/EditModeComplexAttribute/EditModeComplexAttribute.test.js

@@ -115,9 +115,7 @@ describe('EditModeComplexAttribute', function () {
     });
     it('should render additional controls if additionalControlsRenderer prop is specified', function () {
         var AdditionalControls = function () { return React.createElement("div", null); };
-        var props = __assign(__assign({}, defaultProps), { 
-            //eslint-disable-next-line
-            additionalControlsRenderer: function (_a) {
+        var props = __assign(__assign({}, defaultProps), { additionalControlsRenderer: function (_a) {
                 var attributeValue = _a.attributeValue, attributeType = _a.attributeType;
                 return (React.createElement(AdditionalControls, { attributeValue: attributeValue, attributeType: attributeType }));
             } });
@@ -220,9 +218,7 @@ describe('EditModeComplexAttribute', function () {
     };
     it('should render deep nested attributes', function () {
         var AdditionalControls = function () { return React.createElement("div", null); };
-        var props = __assign(__assign({}, defaultProps), { onAddAttributes: jest.fn(), onDeleteAttribute: jest.fn(), onChangeAttribute: jest.fn(), 
-            //eslint-disable-next-line
-            additionalControlsRenderer: function (_a) {
+        var props = __assign(__assign({}, defaultProps), { onAddAttributes: jest.fn(), onDeleteAttribute: jest.fn(), onChangeAttribute: jest.fn(), additionalControlsRenderer: function (_a) {
                 var attributeValue = _a.attributeValue, attributeType = _a.attributeType;
                 return (React.createElement(AdditionalControls, { attributeValue: attributeValue, attributeType: attributeType }));
             }, crosswalks: [], mode: Mode.Editing, showEmptyEditors: true });

package/esm/EmptyState/EmptyState.test.js

@@ -4,7 +4,7 @@ import Button from '@mui/material/Button';
 import { EmptyState } from './EmptyState';
 var Logo = function () { return React.createElement("div", null); };
 describe('EmptyState tests', function () {
-    it('should render main parts ', function () {
+    it('should render main parts', function () {
         var text = 'Header';
         var component = mount(React.createElement(EmptyState, { access: false, LogoRenderer: Logo, text: text }));
         expect(component.find(Logo)).toHaveLength(1);

package/esm/EntitySelector/EntitySelector.test.js

@@ -120,43 +120,61 @@ describe('EntitySelector', function () {
             id: 'test'
         });
     });
-    it('should call typeAheadSearch on DropDownSelector "getOptions" prop calling', function (done) {
-        var entityTypesUris = ['configuration/entityTypes/HCP'];
-        var tempEntity = {
-            entityUri: 'entities/uri$$12345',
-            entityType: entityTypesUris[0]
-        };
-        var wrapper = shallow(React.createElement(EntitySelector, { entity: tempEntity, onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata, max: 5, globalSearchRequestOptions: globalSearchRequestOptions }));
-        wrapper
-            .find('DropDownSelector')
-            .prop('getOptions')()
-            .then(function () {
-            var entityTypes = [metadata.entityTypes[0]];
-            var options = __assign(__assign({}, globalSearchRequestOptions), { max: 5, sendMasked: false });
-            expect(typeAheadSearch).toHaveBeenCalledWith(entityTypes, undefined, options);
-            done();
+    it('should call typeAheadSearch on DropDownSelector "getOptions" prop calling', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var entityTypesUris, tempEntity, wrapper, entityTypes, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    entityTypesUris = ['configuration/entityTypes/HCP'];
+                    tempEntity = {
+                        entityUri: 'entities/uri$$12345',
+                        entityType: entityTypesUris[0]
+                    };
+                    wrapper = shallow(React.createElement(EntitySelector, { entity: tempEntity, onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata, max: 5, globalSearchRequestOptions: globalSearchRequestOptions }));
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                wrapper.find('DropDownSelector').prop('getOptions')();
+                                return [2 /*return*/];
+                            });
+                        }); })];
+                case 1:
+                    _a.sent();
+                    entityTypes = [metadata.entityTypes[0]];
+                    options = __assign(__assign({}, globalSearchRequestOptions), { max: 5, sendMasked: false });
+                    expect(typeAheadSearch).toHaveBeenCalledWith(entityTypes, undefined, options);
+                    return [2 /*return*/];
+            }
         });
-    });
-    it('should call typeAheadSearch on DropDownSelector "getOptions" prop calling with default max param', function (done) {
-        var entityTypesUris = ['configuration/entityTypes/HCP'];
-        var tempEntity = {
-            entityUri: 'entities/uri$$12345',
-            entityType: entityTypesUris[0]
-        };
-        var wrapper = shallow(React.createElement(EntitySelector, { entity: tempEntity, onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
-        wrapper
-            .find('DropDownSelector')
-            .prop('getOptions')()
-            .then(function () {
-            var entityTypes = [metadata.entityTypes[0]];
-            var options = {
-                max: 20,
-                sendMasked: false
-            };
-            expect(typeAheadSearch).toHaveBeenCalledWith(entityTypes, undefined, options);
-            done();
+    }); });
+    it('should call typeAheadSearch on DropDownSelector "getOptions" prop calling with default max param', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var entityTypesUris, tempEntity, wrapper, entityTypes, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    entityTypesUris = ['configuration/entityTypes/HCP'];
+                    tempEntity = {
+                        entityUri: 'entities/uri$$12345',
+                        entityType: entityTypesUris[0]
+                    };
+                    wrapper = shallow(React.createElement(EntitySelector, { entity: tempEntity, onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                wrapper.find('DropDownSelector').prop('getOptions')();
+                                return [2 /*return*/];
+                            });
+                        }); })];
+                case 1:
+                    _a.sent();
+                    entityTypes = [metadata.entityTypes[0]];
+                    options = {
+                        max: 20,
+                        sendMasked: false
+                    };
+                    expect(typeAheadSearch).toHaveBeenCalledWith(entityTypes, undefined, options);
+                    return [2 /*return*/];
+            }
         });
-    });
+    }); });
     it('should render EntityCreator in case temp entity', function () {
         var mdmValues = { modifiedEntities: {} };
         var entityTypesUris = ['configuration/entityTypes/HCP'];
@@ -180,16 +198,25 @@ describe('EntitySelector', function () {
         expect(wrapper.find('EntityCreator')).toHaveLength(0);
     });
     it('should add dummy entity in case empty list of options', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var entityTypesUris, wrapper, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var entityTypesUris, wrapper, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     entityTypesUris = ['configuration/entityTypes/HCP'];
                     wrapper = shallow(React.createElement(EntitySelector, { onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
-                    _a = expect;
-                    return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                                    case 1:
+                                        options = _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
                 case 1:
-                    _a.apply(void 0, [_b.sent()]).toEqual([
+                    _a.sent();
+                    expect(options).toEqual([
                         {
                             label: '',
                             uri: '',
@@ -201,9 +228,9 @@ describe('EntitySelector', function () {
         });
     }); });
     it('should process entities list to get options in case one type', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var entityTypesUris, wrapper, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var entityTypesUris, wrapper, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     entityTypesUris = ['configuration/entityTypes/HCP'];
                     mockEntities = [
@@ -219,10 +246,19 @@ describe('EntitySelector', function () {
                         }
                     ];
                     wrapper = shallow(React.createElement(EntitySelector, { onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
-                    _a = expect;
-                    return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                                    case 1:
+                                        options = _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
                 case 1:
-                    _a.apply(void 0, [_b.sent()]).toEqual([
+                    _a.sent();
+                    expect(options).toEqual([
                         {
                             entityType: {
                                 label: 'HCP',
@@ -247,9 +283,9 @@ describe('EntitySelector', function () {
         });
     }); });
     it('should add label <No label> in case empty label', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var entityTypesUris, wrapper, getOptions, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var entityTypesUris, wrapper, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     entityTypesUris = ['configuration/entityTypes/HCP'];
                     mockEntities = [
@@ -260,11 +296,19 @@ describe('EntitySelector', function () {
                         }
                     ];
                     wrapper = shallow(React.createElement(EntitySelector, { onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
-                    getOptions = wrapper.find('DropDownSelector').prop('getOptions');
-                    _a = expect;
-                    return [4 /*yield*/, getOptions()];
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                                    case 1:
+                                        options = _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
                 case 1:
-                    _a.apply(void 0, [_b.sent()]).toEqual([
+                    _a.sent();
+                    expect(options).toEqual([
                         {
                             entityType: {
                                 label: 'HCP',
@@ -280,9 +324,9 @@ describe('EntitySelector', function () {
         });
     }); });
     it('should process entities list to get options in case two types', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var entityTypesUris, wrapper, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var entityTypesUris, wrapper, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     entityTypesUris = ['configuration/entityTypes/HCP', 'configuration/entityTypes/HCA'];
                     mockEntities = [
@@ -298,10 +342,19 @@ describe('EntitySelector', function () {
                         }
                     ];
                     wrapper = shallow(React.createElement(EntitySelector, { onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
-                    _a = expect;
-                    return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                                    case 1:
+                                        options = _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
                 case 1:
-                    _a.apply(void 0, [_b.sent()]).toEqual([
+                    _a.sent();
+                    expect(options).toEqual([
                         {
                             entityType: 'configuration/entityTypes/HCP',
                             label: 'HCP',
@@ -338,9 +391,9 @@ describe('EntitySelector', function () {
         });
     }); });
     it('should process entities list to get options in case two types with entities only for one type', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var onCreateMock, entityTypesUris, wrapper, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var onCreateMock, entityTypesUris, wrapper, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     onCreateMock = jest.fn();
                     entityTypesUris = ['configuration/entityTypes/HCP', 'configuration/entityTypes/HCA'];
@@ -352,10 +405,19 @@ describe('EntitySelector', function () {
                         }
                     ];
                     wrapper = shallow(React.createElement(EntitySelector, { onCreate: onCreateMock, onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
-                    _a = expect;
-                    return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                                    case 1:
+                                        options = _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
                 case 1:
-                    _a.apply(void 0, [_b.sent()]).toEqual([
+                    _a.sent();
+                    expect(options).toEqual([
                         {
                             entityType: 'configuration/entityTypes/HCP',
                             label: 'HCP',
@@ -403,9 +465,18 @@ describe('EntitySelector', function () {
                         }
                     ];
                     wrapper = shallow(React.createElement(EntitySelector, { onCreate: onCreateMock, onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
-                    return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, wrapper.find('DropDownSelector').prop('getOptions')()];
+                                    case 1:
+                                        options = _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
                 case 1:
-                    options = _a.sent();
+                    _a.sent();
                     expect(options).toEqual([
                         {
                             entityType: {
@@ -421,51 +492,104 @@ describe('EntitySelector', function () {
             }
         });
     }); });
-    it('should not pass onCreate to DropDownSelector if onCreate prop is not provided', function () {
-        var entityTypesUris = ['configuration/entityTypes/HCP'];
-        var wrapper = mount(React.createElement(EntitySelector, { onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
-        expect(wrapper.find('DropDownSelector').prop('onCreate')).toBe(undefined);
-        expect(wrapper.find('DropDownSelector').prop('createLabel')).toBe(undefined);
-    });
-    it('should run onCreate for one type', function () {
-        var entityTypesUris = ['configuration/entityTypes/HCP'];
-        var onCreateMock = jest.fn();
-        var wrapper = mount(React.createElement(EntitySelector, { onChange: mockOnChange, onCreate: onCreateMock, entityTypesUris: entityTypesUris, metadata: metadata }));
-        act(function () { return wrapper.find('DropDownSelector').prop('onInputChange')('someValue'); });
-        wrapper.update();
-        act(function () { return wrapper.find('DropDownSelector').prop('onCreate')('someValue'); });
-        expect(onCreateMock).toHaveBeenCalledWith('configuration/entityTypes/HCP', 'someValue');
-        expect(wrapper.find('DropDownSelector').prop('createLabel')).toEqual('Create "someValue" as new HCP');
-    });
-    it('should run onCreate for several types', function () {
-        var entityTypesUris = ['configuration/entityTypes/HCP', 'configuration/entityTypes/HCA'];
-        var onCreateMock = jest.fn();
-        var wrapper = mount(React.createElement(EntitySelector, { onChange: mockOnChange, onCreate: onCreateMock, entityTypesUris: entityTypesUris, metadata: metadata }));
-        act(function () { return wrapper.find('DropDownSelector').prop('onInputChange')('someValue'); });
-        wrapper.update();
-        act(function () { return wrapper.find('DropDownSelector').prop('onCreate')('someValue', 'configuration/entityTypes/HCA'); });
-        expect(onCreateMock).toHaveBeenCalledWith('configuration/entityTypes/HCA', 'someValue');
-    });
-    it('should run onChange', function () {
-        var entityTypesUris = ['configuration/entityTypes/HCP'];
-        var wrapper = mount(React.createElement(EntitySelector, { onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
-        act(function () {
-            wrapper.find('DropDownSelector').prop('onInputChange')('someValue');
-            wrapper.find('DropDownSelector').prop('onChange')('newValue');
+    it('should not pass onCreate to DropDownSelector if onCreate prop is not provided', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var entityTypesUris, wrapper;
+        return __generator(this, function (_a) {
+            entityTypesUris = ['configuration/entityTypes/HCP'];
+            wrapper = mount(React.createElement(EntitySelector, { onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
+            expect(wrapper.find('DropDownSelector').prop('onCreate')).toBe(undefined);
+            expect(wrapper.find('DropDownSelector').prop('createLabel')).toBe(undefined);
+            return [2 /*return*/];
         });
-        wrapper.update();
-        expect(mockOnChange).toHaveBeenCalledWith('newValue');
-        expect(wrapper.find('Input').prop('value')).toBe('');
-    });
-    it('should run onClear', function () {
-        var entityTypesUris = ['configuration/entityTypes/HCP'];
-        var wrapper = mount(React.createElement(EntitySelector, { onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
-        act(function () {
-            wrapper.find('DropDownSelector').prop('onInputChange')('someValue');
-            wrapper.find('DropDownSelector').prop('onClear')();
+    }); });
+    it('should run onCreate for one type', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var entityTypesUris, onCreateMock, wrapper;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    entityTypesUris = ['configuration/entityTypes/HCP'];
+                    onCreateMock = jest.fn();
+                    wrapper = mount(React.createElement(EntitySelector, { onChange: mockOnChange, onCreate: onCreateMock, entityTypesUris: entityTypesUris, metadata: metadata }));
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                wrapper.find('DropDownSelector').prop('onInputChange')('someValue');
+                                return [2 /*return*/];
+                            });
+                        }); })];
+                case 1:
+                    _a.sent();
+                    wrapper.update();
+                    act(function () { return wrapper.find('DropDownSelector').prop('onCreate')('someValue'); });
+                    expect(onCreateMock).toHaveBeenCalledWith('configuration/entityTypes/HCP', 'someValue');
+                    expect(wrapper.find('DropDownSelector').prop('createLabel')).toEqual('Create "someValue" as new HCP');
+                    return [2 /*return*/];
+            }
         });
-        wrapper.update();
-        expect(mockOnChange).toHaveBeenCalled();
-        expect(wrapper.find('Input').prop('value')).toBe('');
-    });
+    }); });
+    it('should run onCreate for several types', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var entityTypesUris, onCreateMock, wrapper;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    entityTypesUris = ['configuration/entityTypes/HCP', 'configuration/entityTypes/HCA'];
+                    onCreateMock = jest.fn();
+                    wrapper = mount(React.createElement(EntitySelector, { onChange: mockOnChange, onCreate: onCreateMock, entityTypesUris: entityTypesUris, metadata: metadata }));
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                wrapper.find('DropDownSelector').prop('onInputChange')('someValue');
+                                wrapper.find('DropDownSelector').prop('onCreate')('someValue', 'configuration/entityTypes/HCA');
+                                return [2 /*return*/];
+                            });
+                        }); })];
+                case 1:
+                    _a.sent();
+                    expect(onCreateMock).toHaveBeenCalledWith('configuration/entityTypes/HCA', 'someValue');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should run onChange', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var entityTypesUris, wrapper;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    entityTypesUris = ['configuration/entityTypes/HCP'];
+                    wrapper = mount(React.createElement(EntitySelector, { onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                wrapper.find('DropDownSelector').prop('onInputChange')('someValue');
+                                wrapper.find('DropDownSelector').prop('onChange')('newValue');
+                                return [2 /*return*/];
+                            });
+                        }); })];
+                case 1:
+                    _a.sent();
+                    expect(mockOnChange).toHaveBeenCalledWith('newValue');
+                    expect(wrapper.find('Input').prop('value')).toBe('');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should run onClear', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var entityTypesUris, wrapper;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    entityTypesUris = ['configuration/entityTypes/HCP'];
+                    wrapper = mount(React.createElement(EntitySelector, { onChange: mockOnChange, entityTypesUris: entityTypesUris, metadata: metadata }));
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                wrapper.find('DropDownSelector').prop('onInputChange')('someValue');
+                                wrapper.find('DropDownSelector').prop('onClear')();
+                                return [2 /*return*/];
+                            });
+                        }); })];
+                case 1:
+                    _a.sent();
+                    expect(mockOnChange).toHaveBeenCalled();
+                    expect(wrapper.find('Input').prop('value')).toBe('');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/esm/ErrorBoundary/ErrorBoundary.test.js

@@ -4,12 +4,12 @@ import { ErrorBoundary } from './ErrorBoundary';
 describe('ErrorBoundary test', function () {
     var Children = function () { return React.createElement("div", { className: 'children' }); };
     var errorComponent = React.createElement("div", { className: 'error' }, "error");
-    it('it should be render children', function () {
+    it('should be render children', function () {
         var wrapper = mount(React.createElement(ErrorBoundary, { error: errorComponent },
             React.createElement(Children, null)));
         expect(wrapper.find('.children').length).toBe(1);
     });
-    it('it should be render error component after click', function () {
+    it('should be render error component after click', function () {
         jest.spyOn(console, 'error').mockReturnValue();
         var wrapper = mount(React.createElement(ErrorBoundary, { error: errorComponent },
             React.createElement(Children, null)));

package/esm/HOCs/withFilter/components/ColumnFilter/ColumnFilter.js

@@ -30,7 +30,12 @@ export var ColumnFilter = function (_a) {
     var clearFilter = function () { return applyFilterChange(); };
     var applyChangesAndClose = function () {
         var isValidFilter = validateFilter(mdmFilter);
-        isValidFilter ? applyFilterChange(columnFilter) : clearFilter();
+        if (isValidFilter) {
+            applyFilterChange(columnFilter);
+        }
+        else {
+            clearFilter();
+        }
         closeFilterPopup();
     };
     var handleValueEditorKeyPress = function (event) {

package/esm/ImageAttributesLine/types.d.ts

@@ -1,3 +1,4 @@
+import React from 'react';
 import { ImageAttributeValue } from '@reltio/mdm-sdk';
 export type ImageRenderProps = {
     onDownload?: (url: string[]) => void;
@@ -5,4 +6,4 @@ export type ImageRenderProps = {
     onSetAsDefault?: (attributeValue: ImageAttributeValue) => void;
     onOpenImageGalleryDialog: (uri?: string) => void;
 };
-export type RenderImage = (imageRenderProps?: ImageRenderProps) => (attributeValue: ImageAttributeValue) => JSX.Element;
+export type RenderImage = (imageRenderProps?: ImageRenderProps) => (attributeValue: ImageAttributeValue) => React.ReactElement;

package/esm/ImageDetailsView/helpers.test.js

@@ -36,11 +36,6 @@ describe('helpers.ts tests', function () {
             var key = 'CreationDate';
             expect(getFormattedSystemImageAttributeValue(value, key)).toBe('06-09-2021');
         });
-        it('should return undefined if CreationTimestamp was not provided', function () {
-            var value = { value: { CreationTimestamp: [{ uri: '1', value: '' }] } };
-            var key = 'CreationDate';
-            expect(getFormattedSystemImageAttributeValue(value, key)).toBe(undefined);
-        });
         it('should return url if Url was provided', function () {
             var value = { value: { Url: [{ uri: '1', value: 'vk.com' }] } };
             var key = 'Url';

package/esm/ImportButton/ImportButton.test.js

@@ -20,7 +20,7 @@ describe('ImportButton tests', function () {
         wrapper.find(SmallIconButtonWithTooltip).simulate('click');
         expect(onClick).toHaveBeenCalled();
     });
-    it('should render spinner for PROGRESS mode ', function () {
+    it('should render spinner for PROGRESS mode', function () {
         var wrapper = shallow(React.createElement(ImportButton, { mode: ImportModes.Progress }));
         expect(wrapper.find(CircularProgress)).toHaveLength(1);
     });

package/esm/InlineSimpleAttributeEditor/InlineSimpleAttributeEditor.test.js

@@ -158,7 +158,7 @@ describe('InlineSimpleAttributeEditor', function () {
         act(function () {
             dataTypeValueEditor.prop('onChange')(null);
         });
-        expect(component.find(DataTypeValueEditor).prop('value')).toBeNull;
+        expect(component.find(DataTypeValueEditor).prop('value')).toBeNull();
         act(function () {
             component.find(Popover).simulate('keyup', { key: 'Enter' });
         });

package/esm/MapChart/MapChart.js

@@ -38,6 +38,7 @@ var MapChart = function (_a) {
     var colorScale = scaleLog().domain([minValue, maxValue]).range(MAP_COLORS);
     var geography = useGeography(geoUrl || USA_MAP);
     var getProjectionFunc = useCallback(function (projection) {
+        // eslint-disable-next-line import-x/namespace
         var geoFunc = (projection && d3Geo[projection]) || d3Geo['geoEqualEarth'];
         var geoObj = geography.objects && geography.objects[Object.keys(geography.objects)[0]];
         var featureObj = geography.type === 'FeatureCollection' ? geography : feature(geography, geoObj);

package/esm/Marginator/Marginator.d.ts

@@ -3,7 +3,7 @@ type Props = {
     margin: number;
     level: number;
     className?: string;
-    children?: JSX.Element;
+    children?: React.ReactElement;
 };
 export declare const Marginator: ({ margin, level, className, children }: Props) => React.JSX.Element;
 export {};

package/esm/MultiSelect/MultiSelect.js

@@ -190,7 +190,7 @@ MultiSelect.propTypes = {
         valueContainer: PropTypes.func
     }),
     /** Props from https://material-ui.com/api/text-field/ */
-    TextFieldProps: PropTypes.object /* eslint-disable-line react/forbid-prop-types */,
+    TextFieldProps: PropTypes.object,
     getOptions: PropTypes.func,
     menuPlacement: PropTypes.string,
     menuPortalTarget: PropTypes.object,

package/esm/MultipliableSelect/MultipliableSelect.js

@@ -32,9 +32,7 @@ export var MultipliableSelect = function (_a) {
     var _b;
     var multiple = _a.multiple, value = _a.value, children = _a.children, _c = _a.getValueLabel, getValueLabel = _c === void 0 ? defaultGetValueLabel : _c, _d = _a.getValuePlaceholder, getValuePlaceholder = _d === void 0 ? identity : _d, _e = _a.onChange, onChange = _e === void 0 ? identity : _e, fullWidth = _a.fullWidth, TextFieldProps = _a.TextFieldProps, MenuProps = _a.MenuProps, classes = _a.classes, isCrossedOut = _a.isCrossedOut, otherProps = __rest(_a, ["multiple", "value", "children", "getValueLabel", "getValuePlaceholder", "onChange", "fullWidth", "TextFieldProps", "MenuProps", "classes", "isCrossedOut"]);
     var styles = useStyles();
-    return (React.createElement(TextField, __assign({ variant: "standard", select: true, fullWidth: fullWidth }, TextFieldProps, { value: defaultTo(multiple ? [] : '', value), onChange: pipe(getValue, onChange), SelectProps: __assign(__assign({}, otherProps), { MenuProps: __assign({ anchorOrigin: { vertical: 'bottom', horizontal: 'center' } }, MenuProps), classes: __assign(__assign({}, classes), { select: classnames((_b = {}, _b[styles.multiSelect] = multiple, _b[styles.isCrossedOut] = isCrossedOut, _b), prop('root', classes), prop('select', classes)) }), multiple: multiple, 
-            // eslint-disable-next-line react/display-name
-            renderValue: function (selected) {
+    return (React.createElement(TextField, __assign({ variant: "standard", select: true, fullWidth: fullWidth }, TextFieldProps, { value: defaultTo(multiple ? [] : '', value), onChange: pipe(getValue, onChange), SelectProps: __assign(__assign({}, otherProps), { MenuProps: __assign({ anchorOrigin: { vertical: 'bottom', horizontal: 'center' } }, MenuProps), classes: __assign(__assign({}, classes), { select: classnames((_b = {}, _b[styles.multiSelect] = multiple, _b[styles.isCrossedOut] = isCrossedOut, _b), prop('root', classes), prop('select', classes)) }), multiple: multiple, renderValue: function (selected) {
                 return multiple ? (React.createElement("div", { className: styles.chips }, selected.map(function (value, index) { return (React.createElement(ValueChip, { key: value, label: getValueLabel(value) || getValuePlaceholder(value), onMouseDown: function (event) { return event.stopPropagation(); }, onDelete: function () { return onChange(remove(index, 1, selected)); } })); }))) : (getValueLabel(selected) || getValuePlaceholder(selected));
             } }) }), children));
 };

package/esm/PivotingTooltip/components/PivotingTooltipContent/PivotingTooltipContent.test.js

@@ -158,7 +158,7 @@ describe('PivotingTooltipContent test', function () {
             return [2 /*return*/];
         });
     }); });
-    it('should show number of items correctly ', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should show number of items correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
         var component;
         return __generator(this, function (_a) {
             component = setUp();

package/esm/ProfileBand/ProfileBand.js

@@ -27,7 +27,7 @@ export var ProfileBand = function (_a) {
     var isActive = isActiveObject(entity);
     var entityUri = entity.uri;
     var entityId = getEntityId(entity);
-    return (React.createElement("div", { className: classnames(styles.profileBandWrapper, className), "data-reltio-id": 'reltio-profile-band' },
+    return (React.createElement("div", { className: classnames(styles.profileBandWrapper, className), "data-reltio-id": "reltio-profile-band" },
         React.createElement("div", { className: classnames(styles.profileBand, (_b = {},
                 _b[styles.inactive] = !isActive,
                 _b)), "data-entity-uri": entityUri },