@reltio/components 1.4.2006 → 1.4.2008

package/cjs/ReltioMap/ReltioMap.spec.js

@@ -69,6 +69,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -78,22 +87,20 @@ var react_2 = require("@testing-library/react");
 var user_event_1 = __importDefault(require("@testing-library/user-event"));
 var ramda_1 = require("ramda");
 var jest_mocks_1 = require("@googlemaps/jest-mocks");
-var api_1 = require("@react-google-maps/api");
 var constants_1 = require("../constants");
 var helpers = __importStar(require("./helpers"));
 var ReltioMap_1 = require("./ReltioMap");
-jest.mock('@react-google-maps/api', function () { return (__assign(__assign({}, jest.requireActual('@react-google-maps/api')), { useJsApiLoader: jest.fn() })); });
-jest.mock('./components/MapControlContainer', function () { return ({
-    MapControlContainer: function (_a) {
+jest.mock('@vis.gl/react-google-maps', function () { return (__assign(__assign({}, jest.requireActual('@vis.gl/react-google-maps')), { MapControl: function (_a) {
         var children = _a.children;
         return react_1.default.createElement(react_1.default.Fragment, null, children);
-    }
-}); });
+    } })); });
 describe('ReltioMap tests', function () {
     var defaultProps = {
         onOverlayUpdated: jest.fn(),
         onMarkerClicked: jest.fn(),
         isSearchEnabled: true,
+        defaultZoom: 10,
+        defaultCenter: { lat: 1, lng: 1 },
         mapKey: 'mapKey',
         loadingElement: react_1.default.createElement("div", null, "loading element")
     };
@@ -103,15 +110,30 @@ describe('ReltioMap tests', function () {
         return __assign(__assign({}, (0, react_2.render)(react_1.default.createElement(ReltioMap_1.ReltioMap, __assign({}, props)))), { user: user });
     };
     var drawingManagerInstance;
+    var drawingManagerConstructorSpy = jest.fn();
     beforeAll(function () {
         (0, jest_mocks_1.initialize)();
+        var OriginalMap = google.maps.Map;
+        jest.spyOn(google.maps, 'Map').mockImplementation(function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return new (OriginalMap.bind.apply(OriginalMap, __spreadArray([void 0], args, false)))();
+        });
         global.google.maps.drawing.DrawingManager = /** @class */ (function () {
             function DrawingManager() {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                this.addListener = jest.fn();
                 this.getDrawingMode = jest.fn();
                 this.getMap = jest.fn();
                 this.setDrawingMode = jest.fn();
                 this.setMap = jest.fn();
                 this.setOptions = jest.fn();
+                drawingManagerConstructorSpy.apply(void 0, args);
                 drawingManagerInstance = this;
             }
             return DrawingManager;
@@ -132,71 +154,101 @@ describe('ReltioMap tests', function () {
     });
     beforeEach(function () {
         drawingManagerInstance = null;
-        api_1.useJsApiLoader.mockReturnValue({ isLoaded: true, loadError: null });
     });
     afterEach(function () {
         jest.clearAllMocks();
         jest_mocks_1.mockInstances.clearAll();
     });
     var getEventHandler = function (target, event) {
-        return (0, ramda_1.findLast)(function (_a) {
+        var _a, _b;
+        return ((_a = (0, ramda_1.findLast)(function (_a) {
             var instance = _a[0], googleEventName = _a[1];
             return instance === target && googleEventName === event;
-        }, global.google.maps.event.addListener.mock.calls)[2];
+        }, global.google.maps.event.addListener.mock.calls)) === null || _a === void 0 ? void 0 : _a[2]) || ((_b = (0, ramda_1.findLast)(function (_a) {
+            var name = _a[0];
+            return name === event;
+        }, target.addListener.mock.calls)) === null || _b === void 0 ? void 0 : _b[1]);
     };
     var getLastInstance = function (instance) { return (0, ramda_1.last)(jest_mocks_1.mockInstances.get(instance)); };
     describe('general behaviour', function () {
         it('should render map controls', function () { return __awaiter(void 0, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON] }));
-                expect(react_2.screen.getByLabelText('Draw area')).toBeInTheDocument();
-                expect(react_2.screen.getByText('Search as I move the map')).toBeInTheDocument();
-                return [2 /*return*/];
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON] }));
+                        _a = expect;
+                        return [4 /*yield*/, react_2.screen.findByLabelText('Draw area')];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toBeInTheDocument();
+                        expect(react_2.screen.getByText('Search as I move the map')).toBeInTheDocument();
+                        return [2 /*return*/];
+                }
             });
         }); });
         it('should combine mapOptions', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var mapOptions, mapMock;
+            var mapOptions;
             return __generator(this, function (_a) {
-                mapOptions = { mapTypeControl: true };
-                setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], mapOptions: mapOptions }));
-                mapMock = getLastInstance(jest_mocks_1.Map);
-                expect(mapMock.setOptions).toHaveBeenCalledWith({
-                    fullscreenControl: false,
-                    mapTypeControl: true,
-                    streetViewControl: false
-                });
-                return [2 /*return*/];
+                switch (_a.label) {
+                    case 0:
+                        mapOptions = { mapTypeControl: true };
+                        setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], mapOptions: mapOptions }));
+                        return [4 /*yield*/, (0, react_2.waitFor)(function () {
+                                expect(google.maps.Map).toHaveBeenCalledWith(expect.any(HTMLElement), expect.objectContaining({
+                                    fullscreenControl: false,
+                                    mapTypeControl: true,
+                                    streetViewControl: false
+                                }));
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
             });
         }); });
-        it('should not render map controls', function () {
-            setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], isSearchEnabled: false }));
-            expect(react_2.screen.queryByLabelText('Draw area')).not.toBeInTheDocument();
-            expect(react_2.screen.queryByText('Search as I move the map')).not.toBeInTheDocument();
-        });
-        it('should render markers correctly', function () {
-            var markers = [
-                {
-                    point: { lat: 1, lng: 1 },
-                    visible: true,
-                    id: '123',
-                    entity: { uri: 'testUri', type: 'testType' },
-                    label: 'testMarker'
+        it('should not render map controls', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], isSearchEnabled: false }));
+                        return [4 /*yield*/, (0, react_2.waitFor)(function () {
+                                expect(react_2.screen.queryByLabelText('Draw area')).not.toBeInTheDocument();
+                            })];
+                    case 1:
+                        _a.sent();
+                        expect(react_2.screen.queryByText('Search as I move the map')).not.toBeInTheDocument();
+                        return [2 /*return*/];
                 }
-            ];
-            var onMarkerClick = jest.fn();
-            setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], onMarkerClicked: onMarkerClick, markers: markers }));
-            var markerMock = getLastInstance(jest_mocks_1.Marker);
-            getEventHandler(markerMock, 'click')();
-            expect(markerMock.setIcon).toHaveBeenCalled();
-            expect(onMarkerClick).toHaveBeenCalled();
-        });
-        it('should call useJsApiLoader with right params', function () {
-            setUpRTL(__assign({}, defaultProps));
-            expect(api_1.useJsApiLoader).toHaveBeenCalledWith({
-                googleMapsApiKey: 'mapKey',
-                libraries: ['drawing']
             });
-        });
+        }); });
+        it('should render markers correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var markers, onMarkerClick, markerMock;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        markers = [
+                            {
+                                point: { lat: 1, lng: 1 },
+                                visible: true,
+                                id: '123',
+                                entity: { uri: 'testUri', type: 'testType' },
+                                label: 'testMarker'
+                            }
+                        ];
+                        onMarkerClick = jest.fn();
+                        setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], onMarkerClicked: onMarkerClick, markers: markers }));
+                        return [4 /*yield*/, (0, react_2.waitFor)(function () {
+                                markerMock = getLastInstance(jest_mocks_1.AdvancedMarkerElement);
+                                expect(markerMock).toBeDefined();
+                            })];
+                    case 1:
+                        _a.sent();
+                        getEventHandler(markerMock, 'click')();
+                        expect(onMarkerClick).toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('fitting bounds behavior', function () {
         it('should fit map bounds correctly if markers loaded later than map', function () {
@@ -365,7 +417,7 @@ describe('ReltioMap tests', function () {
                         };
                         _a = setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], activeOverlay: activeOverlay })), user = _a.user, rerender = _a.rerender;
                         polygon = getLastInstance(jest_mocks_1.Polygon);
-                        expect(polygon.setPath).toHaveBeenCalledWith(activeOverlay.path);
+                        expect(polygon.setOptions).toHaveBeenCalledWith(expect.objectContaining({ paths: activeOverlay.path }));
                         newProps = __assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], activeOverlay: null });
                         rerender(react_1.default.createElement(ReltioMap_1.ReltioMap, __assign({}, newProps)));
                         return [4 /*yield*/, user.click(react_2.screen.getByLabelText('Draw area'))];
@@ -376,56 +428,100 @@ describe('ReltioMap tests', function () {
                 }
             });
         }); });
-        it('should not render Polygon if "activeOverlay" prop is circle', function () {
-            var activeOverlay = {
-                type: constants_1.MAP_DRAWING_MODES.CIRCLE,
-                path: [{ lat: 1, lng: 1 }]
-            };
-            setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], activeOverlay: activeOverlay }));
-            expect(jest_mocks_1.mockInstances.get(jest_mocks_1.Polygon)).toHaveLength(0);
-        });
-        it('should call props.onOverlayUpdated on polygon mouse up', function () {
-            var activeOverlay = {
-                type: constants_1.MAP_DRAWING_MODES.POLYGON,
-                path: [
-                    { lat: 1, lng: 1 },
-                    { lat: 2, lng: 2 }
-                ]
-            };
-            var onOverlayUpdated = jest.fn();
-            setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], activeOverlay: activeOverlay, onOverlayUpdated: onOverlayUpdated }));
-            var polygon = getLastInstance(jest_mocks_1.Polygon);
-            getEventHandler(polygon, 'mouseup')();
-            expect(onOverlayUpdated).toHaveBeenCalledWith({
-                type: constants_1.MAP_DRAWING_MODES.POLYGON,
-                data: []
+        it('should not render Polygon if "activeOverlay" prop is circle', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var activeOverlay;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        activeOverlay = {
+                            type: constants_1.MAP_DRAWING_MODES.CIRCLE,
+                            path: [{ lat: 1, lng: 1 }]
+                        };
+                        setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], activeOverlay: activeOverlay }));
+                        return [4 /*yield*/, (0, react_2.waitFor)(function () {
+                                expect(jest_mocks_1.mockInstances.get(jest_mocks_1.Polygon)).toHaveLength(0);
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
             });
-            expect(polygon.setPath).toHaveBeenCalledWith(activeOverlay.path);
-        });
-        it('should call props.onOverlayUpdated on polygon drag end', function () {
-            var activeOverlay = {
-                type: constants_1.MAP_DRAWING_MODES.POLYGON,
-                path: [
-                    { lat: 1, lng: 1 },
-                    { lat: 2, lng: 2 }
-                ]
-            };
-            var onOverlayUpdated = jest.fn();
-            setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], activeOverlay: activeOverlay, onOverlayUpdated: onOverlayUpdated }));
-            var polygon = getLastInstance(jest_mocks_1.Polygon);
-            getEventHandler(polygon, 'dragend')();
-            expect(onOverlayUpdated).toHaveBeenCalledWith({
-                type: constants_1.MAP_DRAWING_MODES.POLYGON,
-                data: []
+        }); });
+        it('should call props.onOverlayUpdated on polygon mouse up', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var activeOverlay, onOverlayUpdated, polygon;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        activeOverlay = {
+                            type: constants_1.MAP_DRAWING_MODES.POLYGON,
+                            path: [
+                                { lat: 1, lng: 1 },
+                                { lat: 2, lng: 2 }
+                            ]
+                        };
+                        onOverlayUpdated = jest.fn();
+                        setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], activeOverlay: activeOverlay, onOverlayUpdated: onOverlayUpdated }));
+                        polygon = getLastInstance(jest_mocks_1.Polygon);
+                        getEventHandler(polygon, 'mouseup')();
+                        return [4 /*yield*/, (0, react_2.waitFor)(function () {
+                                expect(onOverlayUpdated).toHaveBeenCalledWith({
+                                    type: constants_1.MAP_DRAWING_MODES.POLYGON,
+                                    data: []
+                                });
+                            })];
+                    case 1:
+                        _a.sent();
+                        expect(polygon.setOptions).toHaveBeenCalledWith(expect.objectContaining({ paths: activeOverlay.path }));
+                        return [2 /*return*/];
+                }
             });
-            expect(polygon.setPath).toHaveBeenCalledWith(activeOverlay.path);
-        });
+        }); });
+        it('should call props.onOverlayUpdated on polygon drag end', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var activeOverlay, onOverlayUpdated, polygon;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        activeOverlay = {
+                            type: constants_1.MAP_DRAWING_MODES.POLYGON,
+                            path: [
+                                { lat: 1, lng: 1 },
+                                { lat: 2, lng: 2 }
+                            ]
+                        };
+                        onOverlayUpdated = jest.fn();
+                        setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.POLYGON], activeOverlay: activeOverlay, onOverlayUpdated: onOverlayUpdated }));
+                        polygon = getLastInstance(jest_mocks_1.Polygon);
+                        getEventHandler(polygon, 'dragend')();
+                        return [4 /*yield*/, (0, react_2.waitFor)(function () {
+                                expect(onOverlayUpdated).toHaveBeenCalledWith({
+                                    type: constants_1.MAP_DRAWING_MODES.POLYGON,
+                                    data: []
+                                });
+                            })];
+                    case 1:
+                        _a.sent();
+                        expect(polygon.setOptions).toHaveBeenCalledWith(expect.objectContaining({ paths: activeOverlay.path }));
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('drawing behavior', function () {
-        it("shouldn't be in drawing mode by default", function () {
-            setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.CIRCLE] }));
-            expect(drawingManagerInstance.setDrawingMode).not.toHaveBeenCalledWith(constants_1.MAP_DRAWING_MODES.CIRCLE);
-        });
+        it("shouldn't be in drawing mode by default", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        setUpRTL(__assign(__assign({}, defaultProps), { drawingModes: [constants_1.MAP_DRAWING_MODES.CIRCLE] }));
+                        return [4 /*yield*/, (0, react_2.waitFor)(function () {
+                                expect(drawingManagerInstance).not.toBe(null);
+                            })];
+                    case 1:
+                        _a.sent();
+                        expect(drawingManagerInstance.setDrawingMode).not.toHaveBeenCalledWith(constants_1.MAP_DRAWING_MODES.CIRCLE);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
         it('should change drawing mode on map control action', function () { return __awaiter(void 0, void 0, void 0, function () {
             var user;
             return __generator(this, function (_a) {
@@ -435,20 +531,40 @@ describe('ReltioMap tests', function () {
                         return [4 /*yield*/, user.click(react_2.screen.getByLabelText('Draw area'))];
                     case 1:
                         _a.sent();
-                        expect(drawingManagerInstance.setDrawingMode).toHaveBeenCalledWith(constants_1.MAP_DRAWING_MODES.CIRCLE);
+                        expect(drawingManagerConstructorSpy).toHaveBeenCalledWith(expect.objectContaining({ drawingMode: constants_1.MAP_DRAWING_MODES.CIRCLE }));
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("shouldn't render DrawingManager without drawingModes prop", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        setUpRTL(__assign({}, defaultProps));
+                        return [4 /*yield*/, (0, react_2.waitFor)(function () {
+                                expect(drawingManagerInstance).toBe(null);
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("shouldn't render TopRightMapControls without drawingModes prop", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        setUpRTL(__assign({}, defaultProps));
+                        return [4 /*yield*/, (0, react_2.waitFor)(function () {
+                                expect(react_2.screen.queryByLabelText('Draw area')).not.toBeInTheDocument();
+                            })];
+                    case 1:
+                        _a.sent();
+                        expect(react_2.screen.queryByLabelText('Clear area')).not.toBeInTheDocument();
                         return [2 /*return*/];
                 }
             });
         }); });
-        it("shouldn't render DrawingManager without drawingModes prop", function () {
-            setUpRTL(__assign({}, defaultProps));
-            expect(drawingManagerInstance).toBe(null);
-        });
-        it("shouldn't render TopRightMapControls without drawingModes prop", function () {
-            setUpRTL(__assign({}, defaultProps));
-            expect(react_2.screen.queryByLabelText('Draw area')).not.toBeInTheDocument();
-            expect(react_2.screen.queryByLabelText('Clear area')).not.toBeInTheDocument();
-        });
         it('should call props.onOverlayUpdated after polygon completing', function () { return __awaiter(void 0, void 0, void 0, function () {
             var onOverlayUpdated, user, overlay;
             return __generator(this, function (_a) {
@@ -459,7 +575,7 @@ describe('ReltioMap tests', function () {
                         return [4 /*yield*/, user.click(react_2.screen.getByLabelText('Draw area'))];
                     case 1:
                         _a.sent();
-                        expect(drawingManagerInstance.setDrawingMode).toHaveBeenLastCalledWith(constants_1.MAP_DRAWING_MODES.POLYGON);
+                        expect(drawingManagerConstructorSpy).toHaveBeenCalledWith(expect.objectContaining({ drawingMode: constants_1.MAP_DRAWING_MODES.POLYGON }));
                         overlay = {
                             setMap: jest.fn(),
                             getPath: function () { return ({
@@ -480,7 +596,7 @@ describe('ReltioMap tests', function () {
                             ]
                         });
                         expect(overlay.setMap).toHaveBeenCalledWith(null);
-                        expect(drawingManagerInstance.setDrawingMode).toHaveBeenLastCalledWith(null);
+                        expect(drawingManagerConstructorSpy).toHaveBeenCalledWith(expect.objectContaining({ drawingMode: null }));
                         return [2 /*return*/];
                 }
             });
@@ -502,11 +618,11 @@ describe('ReltioMap tests', function () {
                         return [4 /*yield*/, user.click(react_2.screen.getByLabelText('Draw area'))];
                     case 1:
                         _a.sent();
-                        expect(drawingManagerInstance.setDrawingMode).toHaveBeenLastCalledWith(constants_1.MAP_DRAWING_MODES.POLYGON);
+                        expect(drawingManagerConstructorSpy).toHaveBeenCalledWith(expect.objectContaining({ drawingMode: constants_1.MAP_DRAWING_MODES.POLYGON }));
                         return [4 /*yield*/, user.click(react_2.screen.getByText('Search as I move the map'))];
                     case 2:
                         _a.sent();
-                        expect(drawingManagerInstance.setDrawingMode).toHaveBeenLastCalledWith(null);
+                        expect(drawingManagerConstructorSpy).toHaveBeenCalledWith(expect.objectContaining({ drawingMode: null }));
                         expect(onMapBoundsChanged).toHaveBeenCalledWith(mapBoundsPolygon);
                         return [2 /*return*/];
                 }
@@ -522,14 +638,14 @@ describe('ReltioMap tests', function () {
                         return [4 /*yield*/, user.click(react_2.screen.getByLabelText('Draw area'))];
                     case 1:
                         _a.sent();
-                        expect(drawingManagerInstance.setDrawingMode).toHaveBeenLastCalledWith(constants_1.MAP_DRAWING_MODES.POLYGON);
+                        expect(drawingManagerConstructorSpy).toHaveBeenCalledWith(expect.objectContaining({ drawingMode: constants_1.MAP_DRAWING_MODES.POLYGON }));
                         return [4 /*yield*/, user.click(react_2.screen.getByText('Search as I move the map'))];
                     case 2:
                         _a.sent();
                         return [4 /*yield*/, user.click(react_2.screen.getByText('Search as I move the map'))];
                     case 3:
                         _a.sent();
-                        expect(drawingManagerInstance.setDrawingMode).toHaveBeenLastCalledWith(null);
+                        expect(drawingManagerConstructorSpy).toHaveBeenCalledWith(expect.objectContaining({ drawingMode: null }));
                         expect(onMapBoundsChanged).toHaveBeenCalledWith(null);
                         return [2 /*return*/];
                 }

package/cjs/ReltioMap/components/ClusteredMarkers/ClusteredMarkers.d.ts

@@ -0,0 +1,11 @@
+import { GeoPoint } from '@reltio/mdm-sdk';
+import React from 'react';
+import { ClusteredMarkersOptions } from '../../types';
+type Props = {
+    entityMarkers: GeoPoint[];
+    enabledClustering: boolean;
+    options?: ClusteredMarkersOptions;
+    onMarkerClick?: (marker: GeoPoint) => void;
+};
+export declare const ClusteredMarkers: React.MemoExoticComponent<({ entityMarkers, options, enabledClustering, onMarkerClick }: Props) => React.JSX.Element>;
+export {};

package/cjs/ReltioMap/components/ClusteredMarkers/ClusteredMarkers.js

@@ -0,0 +1,84 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusteredMarkers = void 0;
+var markerclusterer_1 = require("@googlemaps/markerclusterer");
+var react_google_maps_1 = require("@vis.gl/react-google-maps");
+var ramda_1 = require("ramda");
+var react_1 = __importStar(require("react"));
+var EntityMarker_1 = require("../EntityMarker");
+var CustomClusterRenderer_1 = require("./CustomClusterRenderer");
+exports.ClusteredMarkers = (0, react_1.memo)(function (_a) {
+    var entityMarkers = _a.entityMarkers, options = _a.options, enabledClustering = _a.enabledClustering, onMarkerClick = _a.onMarkerClick;
+    var _b = (0, react_1.useState)({}), markers = _b[0], setMarkers = _b[1];
+    var map = (0, react_google_maps_1.useMap)();
+    var clusterer = (0, react_1.useMemo)(function () {
+        if (!enabledClustering || !map)
+            return null;
+        return new markerclusterer_1.MarkerClusterer({
+            map: map,
+            renderer: new CustomClusterRenderer_1.CustomClusterRenderer(options),
+            algorithmOptions: { maxZoom: options === null || options === void 0 ? void 0 : options.maxZoom }
+        });
+    }, [map, options, enabledClustering]);
+    (0, react_1.useEffect)(function () {
+        return function () {
+            clusterer === null || clusterer === void 0 ? void 0 : clusterer.onRemove();
+        };
+    }, [entityMarkers]);
+    (0, react_1.useEffect)(function () {
+        if (!clusterer)
+            return;
+        clusterer.clearMarkers();
+        clusterer.addMarkers(Object.values(markers));
+    }, [clusterer, markers]);
+    var setMarkerRef = (0, react_1.useCallback)(function (marker, key) {
+        setMarkers(function (markers) {
+            var _a;
+            if (marker && !markers[key]) {
+                return __assign(__assign({}, markers), (_a = {}, _a[key] = marker, _a));
+            }
+            else if (!marker && markers[key]) {
+                return (0, ramda_1.omit)([key], markers);
+            }
+            else {
+                return markers;
+            }
+        });
+    }, []);
+    return (react_1.default.createElement(react_1.default.Fragment, null, entityMarkers.filter((0, ramda_1.prop)('point')).map(function (marker) { return (react_1.default.createElement(EntityMarker_1.EntityMarker, { key: marker.id, marker: marker, clusterer: enabledClustering ? setMarkerRef : undefined, onClick: onMarkerClick })); })));
+});
+exports.ClusteredMarkers.displayName = 'ClusteredMarkers';

package/cjs/ReltioMap/components/ClusteredMarkers/CustomClusterRenderer.d.ts

@@ -0,0 +1,8 @@
+import { Marker, Renderer, Cluster, ClusterStats } from '@googlemaps/markerclusterer';
+import { ClusteredMarkersOptions } from '../../types';
+export declare class CustomClusterRenderer implements Renderer {
+    private options;
+    private defaultRenderer;
+    constructor(options: ClusteredMarkersOptions);
+    render(cluster: Cluster, stats: ClusterStats, map: google.maps.Map): Marker;
+}

package/cjs/ReltioMap/components/ClusteredMarkers/CustomClusterRenderer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomClusterRenderer = void 0;
+var markerclusterer_1 = require("@googlemaps/markerclusterer");
+var CustomClusterRenderer = /** @class */ (function () {
+    function CustomClusterRenderer(options) {
+        this.options = options;
+        this.defaultRenderer = new markerclusterer_1.DefaultRenderer();
+    }
+    CustomClusterRenderer.prototype.render = function (cluster, stats, map) {
+        var _a;
+        var element = this.defaultRenderer.render(cluster, stats, map);
+        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.calculator) && element instanceof google.maps.marker.AdvancedMarkerElement) {
+            var title = this.options.calculator(cluster.markers).title;
+            element.title = title;
+        }
+        return element;
+    };
+    return CustomClusterRenderer;
+}());
+exports.CustomClusterRenderer = CustomClusterRenderer;

package/cjs/ReltioMap/components/ClusteredMarkers/index.d.ts

@@ -0,0 +1 @@
+export { ClusteredMarkers } from './ClusteredMarkers';

package/cjs/ReltioMap/components/ClusteredMarkers/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusteredMarkers = void 0;
+var ClusteredMarkers_1 = require("./ClusteredMarkers");
+Object.defineProperty(exports, "ClusteredMarkers", { enumerable: true, get: function () { return ClusteredMarkers_1.ClusteredMarkers; } });

package/cjs/ReltioMap/components/DrawingManager/DrawingManager.d.ts

@@ -0,0 +1,2 @@
+import { DrawingManagerProps } from './useDrawingManager';
+export declare const DrawingManager: (props: DrawingManagerProps) => any;

package/cjs/ReltioMap/components/DrawingManager/DrawingManager.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawingManager = void 0;
+var useDrawingManager_1 = require("./useDrawingManager");
+var DrawingManager = function (props) {
+    (0, useDrawingManager_1.useDrawingManager)(props);
+    return null;
+};
+exports.DrawingManager = DrawingManager;

package/cjs/ReltioMap/components/DrawingManager/index.d.ts

@@ -0,0 +1 @@
+export { DrawingManager } from './DrawingManager';

package/cjs/ReltioMap/components/DrawingManager/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawingManager = void 0;
+var DrawingManager_1 = require("./DrawingManager");
+Object.defineProperty(exports, "DrawingManager", { enumerable: true, get: function () { return DrawingManager_1.DrawingManager; } });