@reltio/components 1.4.2018 → 1.4.2020

package/BarChart/helpers.d.ts

@@ -4,8 +4,8 @@ import { BarChartOptions } from '@reltio/mdm-sdk';
 type BarChartSettings = {
     barChart: React.ComponentProps<typeof BarChart>;
     bar: Omit<BarProps, 'ref'>;
-    xAxis: XAxisProps;
-    yAxis: YAxisProps;
+    xAxis: Omit<XAxisProps, 'ref'>;
+    yAxis: Omit<YAxisProps, 'ref'>;
     cartesianGrid: Omit<CartesianGridProps, 'ref'>;
     tooltip: TooltipProps<number, string>;
 };

package/BasicTable/IntegrationBasicTable.test.js

@@ -48,16 +48,16 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import React from 'react';
 import { screen, render, within, fireEvent, act } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import HTML5Backend from 'react-dnd-html5-backend';
-import { DndProvider } from 'react-dnd';
+import { mockDndKit } from '../test-utils/dndKit';
+jest.mock('@dnd-kit/core', function () { return mockDndKit; });
 import { BasicTable } from './BasicTable';
 import { CollapseRowButton } from '../CollapseRowButton';
 import { mockBasicTableSizing } from '../test-utils';
 var FirstColumnRenderer = function (_a) {
-    var value = _a.value, rowValue = _a.rowValue, rowIndex = _a.rowIndex, dragRef = _a.dragRef;
+    var value = _a.value, rowValue = _a.rowValue, rowIndex = _a.rowIndex, draggableProps = _a.draggableProps;
     return (React.createElement("div", null,
         React.createElement(CollapseRowButton, { rowIndex: rowIndex, rowValue: rowValue }),
-        React.createElement("div", { ref: dragRef }, "drag el"),
+        React.createElement("div", __assign({}, draggableProps), "drag el"),
         React.createElement("div", null, value.name)));
 };
 var SecondColumnRenderer = function (_a) {
@@ -117,11 +117,7 @@ var defaultProps = {
 };
 var setUp = function (props) {
     var user = userEvent.setup();
-    var Providers = function (_a) {
-        var children = _a.children;
-        return React.createElement(DndProvider, { backend: HTML5Backend }, children);
-    };
-    return __assign(__assign({}, render(React.createElement(BasicTable, __assign({}, props)), { wrapper: Providers })), { user: user });
+    return __assign(__assign({}, render(React.createElement(BasicTable, __assign({}, props)))), { user: user });
 };
 describe('basic table tests', function () {
     it('should collapse all rows after start dragging', function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -153,7 +149,7 @@ describe('basic table tests', function () {
                     dragIndicator = within(getCellByIndexes(1, 0)).queryByText('drag el');
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
-                                fireEvent.dragStart(dragIndicator);
+                                fireEvent.mouseDown(dragIndicator);
                                 return [2 /*return*/];
                             });
                         }); })];
@@ -164,14 +160,6 @@ describe('basic table tests', function () {
                     expect(within(getCellByIndexes(0, 1)).queryByText('row 1 value 3')).not.toBeInTheDocument();
                     expect(within(getCellByIndexes(1, 1)).queryByText('row 2 value 1')).toBeInTheDocument();
                     expect(within(getCellByIndexes(1, 1)).queryByText('row 2 value 2')).not.toBeInTheDocument();
-                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
-                            return __generator(this, function (_a) {
-                                fireEvent.dragEnd(getCellByIndexes(1, 0));
-                                return [2 /*return*/];
-                            });
-                        }); })];
-                case 4:
-                    _a.sent();
                     unmockTableSizing();
                     return [2 /*return*/];
             }

package/EditModeAttributesView/IntegrationEditModeAttributesView.test.js

@@ -48,8 +48,6 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import React from 'react';
 import userEvent from '@testing-library/user-event';
 import { render, screen, act, waitFor } from '@testing-library/react';
-import { DndProvider } from 'react-dnd';
-import HTML5Backend from 'react-dnd-html5-backend';
 import { ErrorType, Mode, getAttributesListForEditMode, uploadImage } from '@reltio/mdm-sdk';
 import { EditModeAttributesView } from './EditModeAttributesView';
 import { MdmModuleProvider } from '../contexts/MdmModuleContext';
@@ -106,9 +104,8 @@ describe('EditModeAttributesView tests', function () {
         var user = userEvent.setup(userOptions);
         var Providers = function (_a) {
             var children = _a.children;
-            return (React.createElement(DndProvider, { backend: HTML5Backend },
-                React.createElement(MdmModuleProvider, { values: mdmValues, actions: mdmActions },
-                    React.createElement(ScrollToElementProvider, null, children))));
+            return (React.createElement(MdmModuleProvider, { values: mdmValues, actions: mdmActions },
+                React.createElement(ScrollToElementProvider, null, children)));
         };
         return __assign({ user: user }, render(React.createElement(EditModeAttributesView, __assign({}, props)), { wrapper: Providers }));
     };

package/HierarchyNodeTitle/useEntityDetails.js

@@ -10,6 +10,9 @@ export var useEntityDetails = function (entityUri) {
         setIsLoading(true);
         safePromise(getEntity(entityUri))
             .then(setEntityDetails)
+            .catch(function (error) {
+            console.warn('Failed to load entity', error);
+        })
             .finally(function () { return setIsLoading(false); });
     }, 1000), [entityUri, safePromise]);
     var hideEntityDetails = useCallback(function () {

package/HierarchyNodeTitle/useEntityDetails.test.js

@@ -194,4 +194,32 @@ describe('useEntityDetails', function () {
             }
         });
     }); });
+    it('should catch and handle error when getEntity returns error', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var warnSpy, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    warnSpy = jest.spyOn(global.console, 'warn');
+                    getEntity.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                    result = renderHook(useEntityDetails, { initialProps: entity.uri }).result;
+                    act(function () {
+                        result.current.showEntityDetails();
+                        jest.runAllTimers();
+                    });
+                    expect(getEntity).toHaveBeenCalled();
+                    return [4 /*yield*/, act(function () {
+                            return Promise.resolve();
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(result.current.isLoading).toBe(false);
+                    expect(warnSpy).toHaveBeenCalledWith('Failed to load entity', {
+                        errorCode: 403,
+                        errorMessage: 'Access is denied'
+                    });
+                    warnSpy.mockRestore();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/ImageAttributesLineEditor/ImageAttributesLineEditor.test.js

@@ -13,8 +13,6 @@ import React from 'react';
 import { act } from 'react-dom/test-utils';
 import ReactResizeDetector from 'react-resize-detector';
 import { mount } from 'enzyme';
-import { DndProvider } from 'react-dnd';
-import HTML5Backend from 'react-dnd-html5-backend';
 import { Mode, insertDefaultImageByAttrUri } from '@reltio/mdm-sdk';
 import { Image } from '../Image';
 import { EmptyStub } from '../EmptyStub';
@@ -91,9 +89,8 @@ var defaultProps = {
 };
 var setUp = function (_a) {
     var _b = _a === void 0 ? {} : _a, _c = _b.props, props = _c === void 0 ? defaultProps : _c, _d = _b.mdmValues, mdmValues = _d === void 0 ? defaultMdmValues : _d, _e = _b.mdmActions, mdmActions = _e === void 0 ? defaultMdmActions : _e;
-    return mount(React.createElement(DndProvider, { backend: HTML5Backend },
-        React.createElement(MdmModuleProvider, { values: mdmValues, actions: mdmActions },
-            React.createElement(ImageAttributesLineEditor, __assign({}, props)))));
+    return mount(React.createElement(MdmModuleProvider, { values: mdmValues, actions: mdmActions },
+        React.createElement(ImageAttributesLineEditor, __assign({}, props))));
 };
 describe('ImageAttributesLineEditor edit tests', function () {
     beforeAll(function () {

package/InlineAttributesPager/components/InlineSimpleAttributesBlock/InlineSimpleAttributesBlock.js

@@ -20,37 +20,48 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import React from 'react';
+import React, { useCallback, useState } from 'react';
 import i18n from 'ui-i18n';
-import { useDrop } from 'react-dnd';
-import { checkMetadataForCreate, isEntityTypeUri, isEntityUri, isRelationTypeUri, isRelationUri, Mode } from '@reltio/mdm-sdk';
+import { useDndMonitor, useDroppable } from '@dnd-kit/core';
+import { canAddCrosswalk } from '@reltio/mdm-sdk';
 import { InlineSimpleAttribute } from '../../../InlineSimpleAttribute';
 import { useStyles } from './styles';
 export var InlineSimpleAttributesBlock = function (_a) {
     var attributeValues = _a.attributeValues, attributeType = _a.attributeType, parentUri = _a.parentUri, disableEdit = _a.disableEdit, crosswalksMap = _a.crosswalksMap, onAdd = _a.onAdd, emptyTempAttributeUris = _a.emptyTempAttributeUris, props = __rest(_a, ["attributeValues", "attributeType", "parentUri", "disableEdit", "crosswalksMap", "onAdd", "emptyTempAttributeUris"]);
     var styles = useStyles();
-    var _b = useDrop({
-        accept: 'Crosswalk',
-        canDrop: function (_a) {
-            var crosswalk = _a.crosswalk;
-            var isRelationCrosswalk = isRelationUri(crosswalk.uri) || crosswalk.ownerType === 'relation';
-            var isEntityCrosswalk = isEntityUri(crosswalk.uri) && crosswalk.ownerType === 'entity';
-            return (checkMetadataForCreate(Mode.Editing, attributeType) &&
-                !disableEdit &&
-                ((isRelationCrosswalk && isRelationTypeUri(attributeType.uri)) ||
-                    (isEntityCrosswalk && isEntityTypeUri(attributeType.uri))));
+    var _b = useState(false), isDragItemOver = _b[0], setIsDragItemOver = _b[1];
+    var checkCanAddCrosswalk = useCallback(function (event) {
+        var _a;
+        var draggingData = event.active.data.current;
+        var crosswalk = draggingData === null || draggingData === void 0 ? void 0 : draggingData.crosswalk;
+        return (!disableEdit &&
+            (draggingData === null || draggingData === void 0 ? void 0 : draggingData.type) === 'Crosswalk' &&
+            attributeType.uri === ((_a = event.over) === null || _a === void 0 ? void 0 : _a.id) &&
+            crosswalk &&
+            canAddCrosswalk(crosswalk, attributeType));
+    }, [disableEdit, attributeType]);
+    useDndMonitor({
+        onDragOver: function (event) {
+            setIsDragItemOver(checkCanAddCrosswalk(event));
         },
-        collect: function (monitor) { return ({
-            isDragItemOver: monitor.isOver() && monitor.canDrop()
-        }); },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        drop: function (_a, monitor) {
-            var crosswalk = _a.crosswalk;
-            onAdd({ attributeType: attributeType, crosswalk: crosswalk, parentUri: parentUri, index: attributeValues.length });
+        onDragEnd: function (event) {
+            var draggingData = event.active.data.current;
+            var crosswalk = draggingData === null || draggingData === void 0 ? void 0 : draggingData.crosswalk;
+            if (checkCanAddCrosswalk(event)) {
+                onAdd({ attributeType: attributeType, crosswalk: crosswalk, parentUri: parentUri, index: attributeValues.length });
+            }
+            setIsDragItemOver(false);
         }
-    }), isDragItemOver = _b[0].isDragItemOver, drop = _b[1];
+    });
+    var setNodeRef = useDroppable({
+        id: attributeType.uri,
+        data: {
+            type: 'Crosswalk',
+            attributeType: attributeType
+        }
+    }).setNodeRef;
     var attributeIndex = 0;
-    return (React.createElement("div", { ref: drop, className: styles.simpleAttributesWrapper, "data-reltio-id": 'simple-attributes-wrapper' },
+    return (React.createElement("div", { ref: setNodeRef, className: styles.simpleAttributesWrapper, "data-reltio-id": 'simple-attributes-wrapper' },
         attributeValues.map(function (value) {
             var _a;
             return (_a = crosswalksMap[value.uri]) === null || _a === void 0 ? void 0 : _a.map(function (crosswalk) { return (React.createElement(InlineSimpleAttribute, __assign({ key: value.uri + crosswalk.uri, attributeType: attributeType, attributeValue: value, crosswalk: crosswalk, disableEdit: disableEdit, isEmpty: emptyTempAttributeUris.includes(value.uri), dataReltioId: "value-index-".concat(attributeIndex++) }, props))); });

package/InlineAttributesPager/components/InlineSimpleAttributesBlock/InlineSimpleAttributesBlock.test.js

@@ -10,10 +10,10 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import React from 'react';
-import { shallow } from 'enzyme';
 import { InlineSimpleAttributesBlock } from './InlineSimpleAttributesBlock';
-import * as reactDnd from 'react-dnd';
-jest.mock('react-dnd', function () { return (__assign(__assign({}, jest.requireActual('react-dnd')), { useDrop: jest.fn() })); });
+import { DndContext, useDndMonitor } from '@dnd-kit/core';
+import { act, render, screen } from '@testing-library/react';
+jest.mock('@dnd-kit/core', function () { return (__assign(__assign({}, jest.requireActual('@dnd-kit/core')), { useDndMonitor: jest.fn() })); });
 describe('InlineSimpleAttributesBlock tests', function () {
     var attributeType = {
         uri: 'configuration/entityTypes/HCP/attributes/Simple',
@@ -73,43 +73,52 @@ describe('InlineSimpleAttributesBlock tests', function () {
         onEdit: jest.fn(),
         onDelete: jest.fn()
     };
-    var props = __assign({ attributeValues: attributeValues, crosswalksMap: crosswalksMap, parentUri: 'entities/1', onAdd: jest.fn(), emptyTempAttributeUris: [] }, commonProps);
-    var useDropMock = jest.spyOn(reactDnd, 'useDrop').mockReturnValue([{}, function () { return null; }]);
+    var defaultProps = __assign({ attributeValues: attributeValues, crosswalksMap: crosswalksMap, parentUri: 'entities/1', onAdd: jest.fn(), emptyTempAttributeUris: [] }, commonProps);
+    var getDragEvent = function (draggingData, attributeType) { return ({
+        active: {
+            data: {
+                current: __assign({}, draggingData)
+            }
+        },
+        over: {
+            id: attributeType.uri
+        }
+    }); };
+    var setUp = function (props) {
+        if (props === void 0) { props = defaultProps; }
+        var Providers = function (_a) {
+            var children = _a.children;
+            return React.createElement(DndContext, null, children);
+        };
+        return render(React.createElement(InlineSimpleAttributesBlock, __assign({}, props)), { wrapper: Providers });
+    };
     it('should render values for each crosswalk', function () {
-        var wrapper = shallow(React.createElement(InlineSimpleAttributesBlock, __assign({}, props)));
-        var attributes = wrapper.find('InlineSimpleAttribute');
-        expect(attributes.length).toBe(3);
-        attributes.forEach(function (attribute) {
-            expect(attribute.props()).toMatchObject(commonProps);
-        });
-        expect(attributes.at(0).prop('attributeValue')).toBe(attributeValues[0]);
-        expect(attributes.at(0).prop('crosswalk')).toBe(crosswalks[0]);
-        expect(attributes.at(1).prop('attributeValue')).toBe(attributeValues[1]);
-        expect(attributes.at(1).prop('crosswalk')).toBe(crosswalks[0]);
-        expect(attributes.at(2).prop('attributeValue')).toBe(attributeValues[1]);
-        expect(attributes.at(2).prop('crosswalk')).toBe(crosswalks[1]);
+        setUp();
+        expect(screen.getByText(attributeValues[0].value)).toBeInTheDocument();
+        expect(screen.getAllByText(attributeValues[1].value)).toHaveLength(2);
     });
-    describe('dnd', function () {
-        afterEach(function () {
-            useDropMock.mockClear();
-        });
-        it('should accept Crosswalk drag items', function () {
-            shallow(React.createElement(InlineSimpleAttributesBlock, __assign({}, props)));
-            var accept = useDropMock.mock.calls[0][0].accept;
-            expect(accept).toEqual('Crosswalk');
+    describe('dnd behavior', function () {
+        var onDragOver, onDragEnd;
+        beforeAll(function () {
+            useDndMonitor.mockImplementation(function (listeners) {
+                onDragOver = listeners.onDragOver;
+                onDragEnd = listeners.onDragEnd;
+            });
         });
         it('should not allow drop relation crosswalk on entity attribute', function () {
-            shallow(React.createElement(InlineSimpleAttributesBlock, __assign({}, props)));
-            var canDrop = useDropMock.mock.calls[0][0].canDrop;
-            expect(canDrop({
-                type: 'Crosswalk',
-                crosswalk: {
-                    uri: 'entities/1/crosswalks/1',
-                    ownerType: 'relation',
-                    type: 'configuration/sources/FB',
-                    value: '123'
-                }
-            }, {})).toBe(false);
+            setUp();
+            act(function () {
+                onDragOver(getDragEvent({
+                    type: 'Crosswalk',
+                    crosswalk: {
+                        uri: 'entities/1/crosswalks/1',
+                        ownerType: 'relation',
+                        type: 'configuration/sources/FB',
+                        value: '123'
+                    }
+                }, defaultProps.attributeType));
+            });
+            expect(screen.queryByText('Drop here')).not.toBeInTheDocument();
         });
         it('should allow drop relation crosswalk on relation attribute', function () {
             var attributeType = {
@@ -132,26 +141,31 @@ describe('InlineSimpleAttributesBlock tests', function () {
                     ov: false
                 }
             ];
-            shallow(React.createElement(InlineSimpleAttributesBlock, __assign({}, props, { attributeType: attributeType, attributeValues: attributeValues })));
-            var canDrop = useDropMock.mock.calls[0][0].canDrop;
-            expect(canDrop({
-                type: 'Crosswalk',
-                crosswalk: {
-                    uri: 'relations/1/crosswalks/1',
-                    ownerType: 'entity',
-                    type: 'configuration/sources/FB',
-                    value: '123'
-                }
-            }, {})).toBe(true);
-            expect(canDrop({
-                type: 'Crosswalk',
-                crosswalk: {
-                    uri: 'entities/1/crosswalks/1',
-                    ownerType: 'relation',
-                    type: 'configuration/sources/FB',
-                    value: '123'
-                }
-            }, {})).toBe(true);
+            setUp(__assign(__assign({}, defaultProps), { attributeType: attributeType, attributeValues: attributeValues }));
+            act(function () {
+                onDragOver(getDragEvent({
+                    type: 'Crosswalk',
+                    crosswalk: {
+                        uri: 'relations/1/crosswalks/1',
+                        ownerType: 'entity',
+                        type: 'configuration/sources/FB',
+                        value: '123'
+                    }
+                }, attributeType));
+            });
+            expect(screen.getByText('Drop here')).toBeInTheDocument();
+            act(function () {
+                onDragOver(getDragEvent({
+                    type: 'Crosswalk',
+                    crosswalk: {
+                        uri: 'entities/1/crosswalks/1',
+                        ownerType: 'relation',
+                        type: 'configuration/sources/FB',
+                        value: '123'
+                    }
+                }, attributeType));
+            });
+            expect(screen.getByText('Drop here')).toBeInTheDocument();
         });
         it('should not allow drop entity crosswalk on relation attribute', function () {
             var attributeType = {
@@ -174,76 +188,70 @@ describe('InlineSimpleAttributesBlock tests', function () {
                     ov: false
                 }
             ];
-            shallow(React.createElement(InlineSimpleAttributesBlock, __assign({}, props, { attributeType: attributeType, attributeValues: attributeValues })));
-            var canDrop = useDropMock.mock.calls[0][0].canDrop;
-            expect(canDrop({
-                type: 'Crosswalk',
-                crosswalk: {
-                    uri: 'entities/1/crosswalks/1',
-                    ownerType: 'entity',
-                    type: 'configuration/sources/FB',
-                    value: '123'
-                }
-            }, {})).toBe(false);
+            setUp(__assign(__assign({}, defaultProps), { attributeType: attributeType, attributeValues: attributeValues }));
+            act(function () {
+                onDragOver(getDragEvent({
+                    type: 'Crosswalk',
+                    crosswalk: {
+                        uri: 'entities/1/crosswalks/1',
+                        ownerType: 'entity',
+                        type: 'configuration/sources/FB',
+                        value: '123'
+                    }
+                }, attributeType));
+            });
+            expect(screen.queryByText('Drop here')).not.toBeInTheDocument();
         });
         it('should not allow drop crosswalk on entity attribute without permission to create', function () {
             var readOnlyAttrType = __assign(__assign({}, attributeType), { access: ['READ'] });
-            shallow(React.createElement(InlineSimpleAttributesBlock, __assign({}, props, { attributeType: readOnlyAttrType })));
-            var canDrop = useDropMock.mock.calls[0][0].canDrop;
-            expect(canDrop({
-                type: 'Crosswalk',
-                crosswalk: {
-                    uri: 'entities/1/crosswalks/1',
-                    ownerType: 'entity',
-                    type: 'configuration/sources/FB',
-                    value: '123'
-                }
-            }, {})).toBe(false);
+            setUp(__assign(__assign({}, defaultProps), { attributeType: readOnlyAttrType, attributeValues: attributeValues }));
+            act(function () {
+                onDragOver(getDragEvent({
+                    type: 'Crosswalk',
+                    crosswalk: {
+                        uri: 'entities/1/crosswalks/1',
+                        ownerType: 'entity',
+                        type: 'configuration/sources/FB',
+                        value: '123'
+                    }
+                }, readOnlyAttrType));
+            });
+            expect(screen.queryByText('Drop here')).not.toBeInTheDocument();
         });
         it('should not allow drop crosswalk on attribute if parent attribute can not be edited', function () {
-            shallow(React.createElement(InlineSimpleAttributesBlock, __assign({}, props, { disableEdit: true })));
-            var canDrop = useDropMock.mock.calls[0][0].canDrop;
-            expect(canDrop({
-                type: 'Crosswalk',
-                crosswalk: {
-                    uri: 'entities/1/crosswalks/1',
-                    ownerType: 'entity',
-                    type: 'configuration/sources/FB',
-                    value: '123'
-                }
-            }, {})).toBe(false);
-        });
-        it('should render drop indicator if crosswalks is over and can be dropped', function () {
-            var wrapper = shallow(React.createElement(InlineSimpleAttributesBlock, __assign({}, props)));
-            var _a = useDropMock.mock.calls[0][0], canDrop = _a.canDrop, collect = _a.collect;
-            expect(canDrop({
-                type: 'Crosswalk',
-                crosswalk: {
-                    uri: 'entities/1/crosswalks/1',
-                    ownerType: 'entity',
-                    type: 'configuration/sources/FB',
-                    value: '123'
-                }
-            }, {})).toBe(true);
-            expect(wrapper.find('.dropIndicator')).toHaveLength(0);
-            collect({ isOver: function () { return true; }, canDrop: function () { return true; } });
-            expect(wrapper.find('.dropIndicator')).toHaveLength(0);
+            setUp(__assign(__assign({}, defaultProps), { disableEdit: true }));
+            act(function () {
+                onDragOver(getDragEvent({
+                    type: 'Crosswalk',
+                    crosswalk: {
+                        uri: 'entities/1/crosswalks/1',
+                        ownerType: 'entity',
+                        type: 'configuration/sources/FB',
+                        value: '123'
+                    }
+                }, defaultProps.attributeType));
+            });
+            expect(screen.queryByText('Drop here')).not.toBeInTheDocument();
         });
         it('should call props.onAdd on crosswalk drop', function () {
-            shallow(React.createElement(InlineSimpleAttributesBlock, __assign({}, props)));
-            var drop = useDropMock.mock.calls[0][0].drop;
+            setUp();
             var crosswalk = {
                 uri: 'entities/1/crosswalks/1',
                 ownerType: 'entity',
                 type: 'configuration/sources/FB',
                 value: '123'
             };
-            drop({ crosswalk: crosswalk, type: 'Crosswalk' }, {});
-            expect(props.onAdd).toHaveBeenCalledWith({
-                parentUri: props.parentUri,
-                attributeType: props.attributeType,
+            act(function () {
+                onDragEnd(getDragEvent({
+                    type: 'Crosswalk',
+                    crosswalk: crosswalk
+                }, defaultProps.attributeType));
+            });
+            expect(defaultProps.onAdd).toHaveBeenCalledWith({
+                parentUri: defaultProps.parentUri,
+                attributeType: defaultProps.attributeType,
                 crosswalk: crosswalk,
-                index: props.attributeValues.length
+                index: defaultProps.attributeValues.length
             });
         });
     });

package/InlineSimpleAttribute/InlineSimpleAttribute.js

@@ -36,7 +36,7 @@ export var InlineSimpleAttribute = function (_a) {
     var showIgnore = !isTemporary && ((!isReadingMode && hasBasicPermission) || attributeValue.ignored);
     var showMaskingSwitcher = (isUnmaskingNeeded && !isTemporary && !isReadingMode) || isUnmasking;
     useEffect(function () {
-        if (isTemporary && !isEmpty) {
+        if (isTemporary && isEmpty) {
             setEditingMode();
         }
     }, [isEmpty]);

package/LineChart/helpers.d.ts

@@ -3,8 +3,8 @@ import { LineChartOptions } from '@reltio/mdm-sdk';
 import { CartesianGridProps, LineChart, LineProps, TooltipProps, XAxisProps, YAxisProps } from 'recharts';
 type LineChartSettings = {
     lineChart: React.ComponentProps<typeof LineChart>;
-    xAxis: XAxisProps;
-    yAxis: YAxisProps;
+    xAxis: Omit<XAxisProps, 'ref'>;
+    yAxis: Omit<YAxisProps, 'ref'>;
     cartesianGrid: Omit<CartesianGridProps, 'ref'>;
     tooltip: TooltipProps<number, string>;
     line: Omit<LineProps, 'ref'>;

package/PieChart/PieChart.test.js

@@ -86,11 +86,15 @@ describe('PieChart', function () {
         expect(wrapper.find(Pie).prop('innerRadius')).toBe('50%');
     });
     it('should call props.onItemClick on sector click', function () {
+        jest.useFakeTimers();
         var onItemClick = jest.fn();
         var wrapper = mount(React.createElement(PieChart, { width: 600, height: 300, data: data, onItemClick: onItemClick }));
+        jest.runAllTimers();
+        wrapper.update();
         var sector = wrapper.find('.recharts-pie-sector').first();
         sector.simulate('click');
         expect(onItemClick).toHaveBeenCalledWith('1');
+        jest.useRealTimers();
     });
     it('should render chart legend with percents correctly', function () {
         var legendPayload = [

package/ProfileBandNavigation/useSearchNavigation.js

@@ -65,7 +65,11 @@ export var useSearchNavigation = function () {
     }, [listenToActions, updateNavigationData, searchNavigationListener]);
     var requestNextPage = useCallback(function (cache, total, index) {
         setLoading(true);
-        safeRequestTotalPromise(searchProvider.requestTotal()).then(function (total) { return updateNavigationData({ total: total }); });
+        safeRequestTotalPromise(searchProvider.requestTotal())
+            .then(function (total) { return updateNavigationData({ total: total }); })
+            .catch(function (error) {
+            console.warn('Failed to load total count of entities', error);
+        });
         var newIndex = index + 1;
         return safeRequestEntitiesPromise(searchProvider.requestEntities(REQUEST_PAGE_SIZE, newIndex))
             .then(function (entities) {
@@ -97,7 +101,11 @@ export var useSearchNavigation = function () {
     }, [searchProvider, updateNavigationData, openEntity]);
     var requestPrevPage = useCallback(function (cache, index) {
         setLoading(true);
-        safeRequestTotalPromise(searchProvider.requestTotal()).then(function (total) { return updateNavigationData({ total: total }); });
+        safeRequestTotalPromise(searchProvider.requestTotal())
+            .then(function (total) { return updateNavigationData({ total: total }); })
+            .catch(function (error) {
+            console.warn('Failed to load total count of entities', error);
+        });
         var newIndex = index - 1;
         var offset = Math.max(0, index - REQUEST_PAGE_SIZE);
         var max = REQUEST_PAGE_SIZE + Math.min(0, index - REQUEST_PAGE_SIZE);
@@ -207,7 +215,7 @@ export var useSearchNavigation = function () {
         if (cache && uri) {
             var cacheIndex = cache.indexOf(uri) - 1;
             stepBackWithCheck(cache, cacheIndex, total, index).catch(function (error) {
-                console.warn("Can't load prev page of search", error);
+                console.warn("Can't load previous page of search", error);
             });
         }
     }, [stepBackWithCheck, cache, uri, total, index]);