@reltio/components 1.4.2155 → 1.4.2157

package/hooks/useCollaboration/useCollaboration.test.js

@@ -92,31 +92,6 @@ describe('useCollaboration behaviour', function () {
         expect(getCommentsCount).not.toHaveBeenCalled();
         expect(getTotalCommentsCount).not.toHaveBeenCalled();
     });
-    it('should not call getCommentsCount if totalCommentsCount is 0', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    getTotalCommentsCount.mockResolvedValue({ total: 0 });
-                    result = setUp().result;
-                    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*/, Promise.resolve()];
-                                    case 1:
-                                        _a.sent();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                case 1:
-                    _a.sent();
-                    expect(getCommentsCount).not.toHaveBeenCalled();
-                    expect(result.current.commentsMap).toEqual({});
-                    return [2 /*return*/];
-            }
-        });
-    }); });
     it('should call getCommentsCount if collaboration is enabled and uris is undefined and update commentsMap value', function () { return __awaiter(void 0, void 0, void 0, function () {
         var result;
         return __generator(this, function (_a) {
@@ -147,7 +122,7 @@ describe('useCollaboration behaviour', function () {
             }
         });
     }); });
-    it('should call getCommentsCount if collaboration is enabled and totalCommentsCount is more then 0 and update commentsMap value', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should call getCommentsCount if collaboration is enabled and update commentsMap value', function () { return __awaiter(void 0, void 0, void 0, function () {
         var comments, result;
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -157,8 +132,12 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id2', status: 'open', replies: 2 }
                     ];
                     getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: comments }]);
-                    getTotalCommentsCount.mockResolvedValueOnce({ total: 2 });
                     result = setUp({ props: { objectIds: ['uri1'] } }).result;
+                    expect(getCommentsCount).toHaveBeenCalledWith({
+                        uris: ['uri1'],
+                        tenant: 'alenat',
+                        collaborationPath: defaultMdmValues.collaborationPath
+                    });
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
@@ -171,24 +150,19 @@ describe('useCollaboration behaviour', function () {
                         }); })];
                 case 1:
                     _a.sent();
-                    expect(getCommentsCount).toHaveBeenCalledWith({
-                        uris: ['uri1'],
-                        tenant: 'alenat',
-                        collaborationPath: defaultMdmValues.collaborationPath
-                    });
                     expect(result.current.commentsMap).toEqual({ uri1: comments });
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should set commentsMap value as null in case of unsuccessful getCommentsCount request', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should set commentsMap value as null in case of unsuccessful request', function () { return __awaiter(void 0, void 0, void 0, function () {
         var result;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    getTotalCommentsCount.mockResolvedValueOnce({ total: 1 });
-                    getCommentsCount.mockRejectedValueOnce(new Error('Fail'));
+                    getCommentsCount.mockRejectedValueOnce(null);
                     result = setUp().result;
+                    expect(getCommentsCount).toHaveBeenCalled();
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
@@ -201,7 +175,6 @@ describe('useCollaboration behaviour', function () {
                         }); })];
                 case 1:
                     _a.sent();
-                    expect(getCommentsCount).toHaveBeenCalled();
                     expect(result.current.commentsMap).toBe(null);
                     return [2 /*return*/];
             }
@@ -223,20 +196,7 @@ describe('useCollaboration behaviour', function () {
                             return Promise.resolve([{ objectId: 'uri2', comments: secondComments }]);
                         }
                     });
-                    getTotalCommentsCount.mockResolvedValueOnce({ total: 3 });
                     result = setUp({ props: { objectIds: ['uri1'] } }).result;
-                    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*/, Promise.resolve()];
-                                    case 1:
-                                        _a.sent();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                case 1:
-                    _a.sent();
                     expect(getCommentsCount).toHaveBeenCalledWith({
                         uris: ['uri1'],
                         tenant: 'alenat',
@@ -248,7 +208,7 @@ describe('useCollaboration behaviour', function () {
                                 return [2 /*return*/];
                             });
                         }); })];
-                case 2:
+                case 1:
                     _a.sent();
                     expect(getCommentsCount).toHaveBeenCalledWith({
                         uris: ['uri2'],
@@ -276,20 +236,7 @@ describe('useCollaboration behaviour', function () {
                             return Promise.resolve([{ objectId: 'uri2', comments: secondComments }]);
                         }
                     });
-                    getTotalCommentsCount.mockResolvedValue({ total: 3 });
                     _a = setUp({ props: { objectIds: ['uri1'] } }), result = _a.result, rerender = _a.rerender;
-                    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*/, Promise.resolve()];
-                                    case 1:
-                                        _a.sent();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                case 1:
-                    _b.sent();
                     expect(getCommentsCount).toHaveBeenCalledWith({
                         uris: ['uri1'],
                         tenant: 'alenat',
@@ -307,7 +254,7 @@ describe('useCollaboration behaviour', function () {
                                 }
                             });
                         }); })];
-                case 2:
+                case 1:
                     _b.sent();
                     expect(getCommentsCount).toHaveBeenCalledWith({
                         uris: ['uri2'],
@@ -444,12 +391,7 @@ describe('useCollaboration behaviour', function () {
                             replies: 2
                         }
                     ];
-                    getTotalCommentsCount.mockResolvedValueOnce({ total: 3 });
-                    getCommentsCount
-                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: comments }])
-                        .mockResolvedValueOnce([
-                        { objectId: 'uri1', comments: __spreadArray(__spreadArray([], comments, true), [{ commentId: 'commentId', replies: 0, status: 'open' }], false) }
-                    ]);
+                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: comments }]);
                     createComment.mockResolvedValueOnce([{ commentId: 'commentId' }]);
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -467,16 +409,33 @@ describe('useCollaboration behaviour', function () {
                     expect(result.current.commentsMap).toEqual({ uri1: comments });
                     expect(result.current.currentComment).toBe(null);
                     expect(result.current.sending).toBe(false);
+                    act(function () {
+                        result.current.createComment({
+                            content: 'content',
+                            namedUsers: [],
+                            objectType: 'entity',
+                            relatedObjectUris: ['uri1'],
+                            uri: 'uri1'
+                        });
+                    });
+                    expect(result.current.sending).toBe(true);
+                    expect(createComment).toHaveBeenCalledWith({
+                        collaborationPath: '123',
+                        tenant: 'alenat',
+                        data: {
+                            objectId: 'uri1',
+                            content: 'content',
+                            relatedObjectUris: ['uri1'],
+                            objectType: 'entity',
+                            visibility: 'public',
+                            namedUsers: [],
+                            permanentLink: 'https://tst-01.reltio.com/nui/alenat/profile?entityUri=entities%2F2jWtLtNc&commentId=%7BcommentId%7D'
+                        }
+                    });
                     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*/, result.current.createComment({
-                                            content: 'content',
-                                            namedUsers: [],
-                                            objectType: 'entity',
-                                            relatedObjectUris: ['uri1'],
-                                            uri: 'uri1'
-                                        })];
+                                    case 0: return [4 /*yield*/, Promise.resolve()];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -493,23 +452,15 @@ describe('useCollaboration behaviour', function () {
                         uri1: __spreadArray(__spreadArray([], comments, true), [{ commentId: 'commentId', replies: 0, status: 'open' }], false)
                     });
                     createComment.mockResolvedValueOnce([{ commentId: 'commentId2' }]);
-                    getCommentsCount.mockResolvedValueOnce([
-                        { objectId: 'uri1', comments: __spreadArray(__spreadArray([], comments, true), [{ commentId: 'commentId', replies: 0, status: 'open' }], false) },
-                        { objectId: 'uri2', comments: [{ commentId: 'commentId2', replies: 0, status: 'open' }] }
-                    ]);
                     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*/, result.current.createComment({
-                                            content: 'content',
-                                            namedUsers: [],
-                                            objectType: 'entity',
-                                            uri: 'uri2'
-                                        })];
-                                    case 1:
-                                        _a.sent();
-                                        return [2 /*return*/];
-                                }
+                                result.current.createComment({
+                                    content: 'content',
+                                    namedUsers: [],
+                                    objectType: 'entity',
+                                    uri: 'uri2'
+                                });
+                                return [2 /*return*/];
                             });
                         }); })];
                 case 3:
@@ -538,14 +489,7 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id1', content: 'first comment', status: 'open', replies: [] },
                         { commentId: 'id2', content: 'second comment', status: 'open', replies: [] }
                     ];
-                    getCommentsCount
-                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
-                        .mockResolvedValueOnce([
-                        { objectId: 'uri1', comments: [commentsCount[0], { commentId: 'id2', status: 'open', replies: 3 }] }
-                    ])
-                        .mockResolvedValueOnce([
-                        { objectId: 'uri1', comments: [commentsCount[0], { commentId: 'id2', status: 'resolved', replies: 4 }] }
-                    ]);
+                    getCommentsCount.mockResolvedValue([{ objectId: 'uri1', comments: commentsCount }]);
                     getComments.mockResolvedValue({ items: comments });
                     getComment.mockResolvedValueOnce({
                         commentId: 'id2',
@@ -678,11 +622,7 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id1', status: 'open', content: 'first comment', replies: [] },
                         { commentId: 'id2', status: 'open', content: 'second comment', replies: [] }
                     ];
-                    getCommentsCount
-                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
-                        .mockResolvedValueOnce([
-                        { objectId: 'uri1', comments: [commentsCount[0], { commentId: 'id2', status: 'resolved', replies: 3 }] }
-                    ]);
+                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }]);
                     getComment.mockResolvedValueOnce({ commentId: 'id2', replies: [] });
                     getComments.mockResolvedValue({ items: comments });
                     createReply.mockResolvedValueOnce([{ content: '', action: 'resolve' }]);
@@ -755,11 +695,7 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id1', status: 'open', content: 'first comment', replies: [] },
                         { commentId: 'id2', status: 'open', content: 'second comment', replies: [] }
                     ];
-                    getCommentsCount
-                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
-                        .mockResolvedValueOnce([
-                        { objectId: 'uri1', comments: [commentsCount[0], { commentId: 'id2', status: 'open', replies: 3 }] }
-                    ]);
+                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }]);
                     getComment.mockResolvedValueOnce({ commentId: 'id2', replies: [] });
                     getComments.mockResolvedValue({
                         items: comments
@@ -932,12 +868,9 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id1', content: 'text 1', status: 'open', replies: [] },
                         { commentId: 'id2', content: 'text2', status: 'open', replies: [] }
                     ];
-                    expectedCommentsCount = [{ commentId: 'id2', status: 'open', replies: 0 }];
-                    expectedComments = [{ commentId: 'id2', content: 'text2', status: 'open', replies: [] }];
-                    getTotalCommentsCount.mockResolvedValueOnce({ total: 2 });
-                    getCommentsCount
-                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
-                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: expectedCommentsCount }]);
+                    expectedCommentsCount = commentsCount.slice(1);
+                    expectedComments = comments.slice(1);
+                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }]);
                     getComments.mockResolvedValueOnce({ items: comments });
                     deleteComment.mockResolvedValueOnce('');
                     result = setUp().result;
@@ -952,20 +885,28 @@ describe('useCollaboration behaviour', function () {
                     expect(result.current.comments).toEqual(comments);
                     expect(result.current.commentsMap).toEqual({ uri1: commentsCount });
                     expect(result.current.sending).toBe(false);
+                    act(function () {
+                        result.current.deleteComment({ commentId: 'id1', uri: 'uri1' });
+                    });
+                    expect(result.current.sending).toBe(true);
+                    expect(deleteComment).toHaveBeenCalledWith({
+                        collaborationPath: '123',
+                        tenant: 'alenat',
+                        commentId: 'id1'
+                    });
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
-                                result.current.deleteComment({ commentId: 'id1', uri: 'uri1' });
-                                return [2 /*return*/];
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, Promise.resolve()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
                             });
                         }); })];
                 case 2:
                     _a.sent();
                     expect(result.current.sending).toBe(false);
-                    expect(deleteComment).toHaveBeenCalledWith({
-                        collaborationPath: '123',
-                        tenant: 'alenat',
-                        commentId: 'id1'
-                    });
                     expect(result.current.commentsMap).toEqual({
                         uri1: expectedCommentsCount
                     });
@@ -983,23 +924,13 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id1', status: 'open', replies: 1 },
                         { commentId: 'id2', status: 'open', replies: 2 }
                     ];
-                    getTotalCommentsCount.mockResolvedValueOnce({ total: commentsCount.length });
-                    getCommentsCount
-                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
-                        .mockResolvedValueOnce([
-                        { objectId: 'uri1', comments: [commentsCount[0], { commentId: 'id2', status: 'open', replies: 2 }] },
-                        { objectId: 'uri2', comments: [] }
-                    ]);
+                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }]);
                     createReply.mockResolvedValueOnce([{ content: 'reply message' }]);
                     result = setUp().result;
                     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*/, Promise.resolve()];
-                                    case 1:
-                                        _a.sent();
-                                        return [2 /*return*/];
-                                }
+                                Promise.resolve();
+                                return [2 /*return*/];
                             });
                         }); })];
                 case 1:
@@ -1016,9 +947,6 @@ describe('useCollaboration behaviour', function () {
                                             uri: 'uri2'
                                         })];
                                     case 1:
-                                        _a.sent();
-                                        return [4 /*yield*/, Promise.resolve()];
-                                    case 2:
                                         _a.sent();
                                         return [2 /*return*/];
                                 }
@@ -1045,23 +973,14 @@ describe('useCollaboration behaviour', function () {
                     ];
                     expectedCommentsCount = [{ commentId: 'id1', status: 'open', replies: 0 }];
                     expectedComments = [{ commentId: 'id1', content: 'text 1', status: 'open', replies: [] }];
-                    getTotalCommentsCount.mockResolvedValueOnce({ total: 2 }).mockResolvedValueOnce({ total: 1 });
-                    getCommentsCount
-                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
-                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: expectedCommentsCount }]);
+                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }]);
                     getComments.mockResolvedValue({ items: comments });
                     deleteReply.mockResolvedValueOnce('');
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        result.current.getComments('uri');
-                                        return [4 /*yield*/, Promise.resolve()];
-                                    case 1:
-                                        _a.sent();
-                                        return [2 /*return*/];
-                                }
+                                result.current.getComments('uri');
+                                return [2 /*return*/];
                             });
                         }); })];
                 case 1:
@@ -1069,16 +988,24 @@ describe('useCollaboration behaviour', function () {
                     expect(result.current.comments).toEqual(comments);
                     expect(result.current.commentsMap).toEqual({ uri1: commentsCount });
                     expect(result.current.sending).toBe(false);
+                    act(function () {
+                        result.current.deleteReply({
+                            commentId: 'id1',
+                            uri: 'uri1',
+                            reply: comments[0].replies[0]
+                        });
+                    });
+                    expect(result.current.sending).toBe(true);
+                    expect(deleteReply).toHaveBeenCalledWith({
+                        collaborationPath: '123',
+                        tenant: 'alenat',
+                        commentId: 'id1',
+                        replyId: 'replyId1'
+                    });
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
-                                    case 0:
-                                        result.current.deleteReply({
-                                            commentId: 'id1',
-                                            uri: 'uri1',
-                                            reply: comments[0].replies[0]
-                                        });
-                                        return [4 /*yield*/, Promise.resolve()];
+                                    case 0: return [4 /*yield*/, Promise.resolve()];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -1088,12 +1015,6 @@ describe('useCollaboration behaviour', function () {
                 case 2:
                     _a.sent();
                     expect(result.current.sending).toBe(false);
-                    expect(deleteReply).toHaveBeenCalledWith({
-                        collaborationPath: '123',
-                        tenant: 'alenat',
-                        commentId: 'id1',
-                        replyId: 'replyId1'
-                    });
                     expect(result.current.commentsMap).toEqual({
                         uri1: expectedCommentsCount
                     });
@@ -1125,7 +1046,6 @@ describe('useCollaboration behaviour', function () {
                     updateReply.mockResolvedValueOnce(editedReply);
                     getComment.mockResolvedValueOnce(initialComment);
                     getComments.mockResolvedValueOnce({ items: initialComments });
-                    getTotalCommentsCount.mockResolvedValue({ total: 2 });
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
@@ -1182,7 +1102,6 @@ describe('useCollaboration behaviour', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    getTotalCommentsCount.mockResolvedValue({ total: 1 });
                     result = setUp().result;
                     expect(result.current.getCommentState('attrUri', 'commentUri')).toEqual({});
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -1225,7 +1144,6 @@ describe('useCollaboration behaviour', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    getTotalCommentsCount.mockResolvedValue({ total: 1 });
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
@@ -1262,7 +1180,6 @@ describe('useCollaboration behaviour', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    getTotalCommentsCount.mockResolvedValue({ total: 1 });
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
@@ -1326,13 +1243,37 @@ describe('useCollaboration behaviour', function () {
             expect(result.current.totalCommentsCount).toBe(null);
             expect(getTotalCommentsCount).not.toHaveBeenCalled();
         });
-        it('should call getTotalCommentsCount if collaboration is enabled and update totalCommentsCount value', function () { return __awaiter(void 0, void 0, void 0, function () {
+        it('should not call getTotalCommentsCount and update totalCommentsCount value if collaboration is enabled but needsTotalCount is false', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        getTotalCommentsCount.mockResolvedValueOnce({ total: 15 });
+                        setUp();
+                        expect(getTotalCommentsCount).not.toHaveBeenCalled();
+                        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*/, Promise.resolve()];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        expect(getTotalCommentsCount).not.toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should call getTotalCommentsCount and update totalCommentsCount value if collaboration is enabled and needsTotalCount is true', function () { return __awaiter(void 0, void 0, void 0, function () {
             var result;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         getTotalCommentsCount.mockResolvedValueOnce({ total: 15 });
-                        result = setUp().result;
+                        result = setUp({ props: { needsTotalCount: true } }).result;
                         expect(getTotalCommentsCount).toHaveBeenCalledWith({
                             relatedObjectUri: '1',
                             collaborationPath: '123',
@@ -1361,7 +1302,7 @@ describe('useCollaboration behaviour', function () {
                 switch (_a.label) {
                     case 0:
                         getTotalCommentsCount.mockRejectedValueOnce(new Error('Network error'));
-                        result = setUp().result;
+                        result = setUp({ props: { needsTotalCount: true } }).result;
                         expect(getTotalCommentsCount).toHaveBeenCalled();
                         return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                                 return __generator(this, function (_a) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reltio/components",
-  "version": "1.4.2155",
+  "version": "1.4.2157",
   "license": "SEE LICENSE IN LICENSE FILE",
   "main": "./cjs/index.js",
   "module": "./index.js",
@@ -11,7 +11,7 @@
     "@fluentui/react-context-selector": "^9.1.26",
     "@googlemaps/markerclusterer": "^2.5.3",
     "@react-sigma/core": "3.4.0",
-    "@reltio/mdm-sdk": "^1.4.1976",
+    "@reltio/mdm-sdk": "^1.4.1977",
     "@vis.gl/react-google-maps": "^1.3.0",
     "d3-cloud": "^1.2.5",
     "d3-geo": "^2.0.1",