@inlog/inlog-maps 4.9.4 → 5.0.1

package/DOCUMENTATION.md

@@ -1,4 +1,4 @@
-# [@inlog/inlog-maps](https://github.com/weareinlog/inlog-maps#readme) *4.9.4*
+# [@inlog/inlog-maps](https://github.com/weareinlog/inlog-maps#readme) *5.0.1*
 
 > A library for using generic layer maps 
 

package/_bundles/inlog-maps.js

@@ -120,15 +120,18 @@ var CircleEventType;
 })(CircleEventType = exports.CircleEventType || (exports.CircleEventType = {}));
 var PolygonEventType;
 (function (PolygonEventType) {
-    PolygonEventType[PolygonEventType["InsertAt"] = 0] = "InsertAt";
-    PolygonEventType[PolygonEventType["Move"] = 1] = "Move";
-    PolygonEventType[PolygonEventType["Click"] = 2] = "Click";
+    PolygonEventType[PolygonEventType["SetAt"] = 0] = "SetAt";
+    PolygonEventType[PolygonEventType["InsertAt"] = 1] = "InsertAt";
+    PolygonEventType[PolygonEventType["RemoveAt"] = 2] = "RemoveAt";
+    PolygonEventType[PolygonEventType["DragPolygon"] = 3] = "DragPolygon";
+    PolygonEventType[PolygonEventType["Click"] = 4] = "Click";
 })(PolygonEventType = exports.PolygonEventType || (exports.PolygonEventType = {}));
 var PolylineEventType;
 (function (PolylineEventType) {
-    PolylineEventType[PolylineEventType["Move"] = 0] = "Move";
+    PolylineEventType[PolylineEventType["SetAt"] = 0] = "SetAt";
     PolylineEventType[PolylineEventType["InsertAt"] = 1] = "InsertAt";
     PolylineEventType[PolylineEventType["RemoveAt"] = 2] = "RemoveAt";
+    PolylineEventType[PolylineEventType["DragPolyline"] = 3] = "DragPolyline";
 })(PolylineEventType = exports.PolylineEventType || (exports.PolylineEventType = {}));
 
 
@@ -238,14 +241,14 @@ var MapsApiLoaderService = /** @class */ (function () {
     MapsApiLoaderService.loadLeafletAPI = function (params) {
         var link = document.createElement('link');
         link.rel = 'stylesheet';
-        link.href = 'https://unpkg.com/leaflet@1.4.0/dist/leaflet.css';
+        link.href = 'https://desenvolvimentoweb.blob.core.windows.net/inlog-leaflet/leaflet.css';
         // link.integrity = params.cssIntegrity;
         // link.setAttribute('crossorigin', params.crossorigin);
         document.querySelector('head').appendChild(link);
         var script = document.createElement('script');
         script.type = 'text/javascript';
         script.src = url_builder_1.urlBuilder({
-            base: 'https://unpkg.com/leaflet@1.4.0/dist/leaflet.js',
+            base: 'https://desenvolvimentoweb.blob.core.windows.net/inlog-leaflet/leaflet.js',
             callback: 'mapsAPILoadCallback',
         });
         document.querySelector('head').appendChild(script);
@@ -4110,13 +4113,8 @@ var GooglePolygons = /** @class */ (function () {
     }
     GooglePolygons.prototype.drawPolygon = function (options, eventClick) {
         var self = this;
-        var paths = [];
-        options.path.forEach(function (path) {
-            paths.push({
-                lat: path[0],
-                lng: path[1]
-            });
-        });
+        var paths = this.getPathRecursiveArray(options.path);
+        paths = this.getPathPolylineArray(paths);
         var newOptions = {
             draggable: options.draggable,
             editable: options.editable,
@@ -4184,31 +4182,26 @@ var GooglePolygons = /** @class */ (function () {
         return !!polygon.map;
     };
     GooglePolygons.prototype.getPolygonPath = function (polygon) {
-        return polygon.getPath().getArray().map(function (x) { return [x.lat(), x.lng()]; });
+        return polygon.getPaths().getArray().map(function (x) { return x.getArray().map(function (y) { return new event_return_1.default([y.lat(), y.lng()]); }); });
     };
     GooglePolygons.prototype.addPolygonEvent = function (polygons, eventType, eventFunction) {
         var _this = this;
         polygons.forEach(function (polygon) {
             switch (eventType) {
-                case event_type_1.PolygonEventType.Move:
-                    _this.google.maps.event.addListener(polygon.getPath(), 'set_at', function (event) {
-                        var param = new event_return_1.default([polygon.getPath()
-                                .getAt(event).lat(), polygon.getPath().getAt(event).lng()]);
-                        eventFunction(param, polygon.getPath().getArray().map(function (x) { return [x.lat(), x.lng()]; }), polygon.object);
-                    });
+                case event_type_1.PolygonEventType.SetAt:
+                    _this.addPolygonEventMove(polygon, eventFunction);
                     break;
                 case event_type_1.PolygonEventType.InsertAt:
-                    _this.google.maps.event.addListener(polygon.getPath(), 'insert_at', function (event) {
-                        var param = new event_return_1.default([polygon.getPath()
-                                .getAt(event).lat(), polygon.getPath().getAt(event).lng()]);
-                        eventFunction(param, polygon.getPath().getArray().map(function (x) { return [x.lat(), x.lng()]; }), polygon.object);
-                    });
+                    _this.addPolygonEventInsertAt(polygon, eventFunction);
+                    break;
+                case event_type_1.PolygonEventType.RemoveAt:
+                    _this.addPolygonEventRemoveAt(polygon, eventFunction);
+                    break;
+                case event_type_1.PolygonEventType.DragPolygon:
+                    _this.addPolygonEventDragPolygon(polygon, eventFunction);
                     break;
                 case event_type_1.PolygonEventType.Click:
-                    _this.google.maps.event.addListener(polygon, 'click', function (event) {
-                        var param = new event_return_1.default([event.latLng.lat(), event.latLng.lng()]);
-                        eventFunction(param, polygon.object);
-                    });
+                    _this.addPolygonEventClick(polygon, eventFunction);
                     break;
                 default:
                     break;
@@ -4219,11 +4212,18 @@ var GooglePolygons = /** @class */ (function () {
         var _this = this;
         polygons.forEach(function (polygon) {
             switch (event) {
-                case event_type_1.PolygonEventType.Move:
-                    _this.google.maps.event.clearListeners(polygon.getPath(), 'set_at');
+                case event_type_1.PolygonEventType.SetAt:
+                    _this.google.maps.event.clearListeners(polygon.getPaths(), 'set_at');
                     break;
                 case event_type_1.PolygonEventType.InsertAt:
-                    _this.google.maps.event.clearListeners(polygon.getPath(), 'insert_at');
+                    _this.google.maps.event.clearListeners(polygon.getPaths(), 'insert_at');
+                    break;
+                case event_type_1.PolygonEventType.RemoveAt:
+                    _this.google.maps.event.clearListeners(polygon.getPaths(), 'remove_at');
+                    break;
+                case event_type_1.PolygonEventType.DragPolygon:
+                    _this.google.maps.event.clearListeners(polygon, 'dragstart');
+                    _this.google.maps.event.clearListeners(polygon, 'dragend');
                     break;
                 case event_type_1.PolygonEventType.Click:
                     _this.google.maps.event.clearListeners(polygon, 'click');
@@ -4237,19 +4237,93 @@ var GooglePolygons = /** @class */ (function () {
         var bounds = new this.google.maps.LatLngBounds();
         polygons.forEach(function (polygon) {
             var paths = polygon.getPaths().getArray();
-            paths.forEach(function (path) { return path.getArray()
-                .forEach(function (x) { return bounds.extend(x); }); });
+            paths.forEach(function (path) { return path.getArray().forEach(function (x) { return bounds.extend(x); }); });
         });
         return bounds;
     };
     GooglePolygons.prototype.getPolygonBounds = function (polygon) {
         var bounds = new this.google.maps.LatLngBounds();
         var paths = polygon.getPaths().getArray();
-        paths.forEach(function (path) {
-            path.getArray().forEach(function (x) { return bounds.extend(x); });
-        });
+        paths.forEach(function (path) { return path.getArray().forEach(function (x) { return bounds.extend(x); }); });
         return bounds;
     };
+    GooglePolygons.prototype.addPolygonEventMove = function (polygon, eventFunction) {
+        var polygonPathIdx = polygon.getPaths().getLength();
+        for (var index = 0; index < polygonPathIdx; index++) {
+            this.addPolygonEventMoveAllPaths(polygon, polygon.getPaths().getAt(index), eventFunction);
+        }
+    };
+    GooglePolygons.prototype.addPolygonEventMoveAllPaths = function (polygon, innerPolygon, eventFunction) {
+        this.google.maps.event.addListener(innerPolygon, 'set_at', function (newEvent, lastEvent) {
+            if (polygon.dragging)
+                return;
+            var path = innerPolygon.getAt(newEvent);
+            var newPosition = new event_return_1.default([path.lat(), path.lng()]);
+            var lastPosition = new event_return_1.default([lastEvent.lat(), lastEvent.lng()]);
+            eventFunction(newPosition, lastPosition, polygon.object, newEvent, polygon.getPaths().getArray().map(function (x) { return x.getArray().map(function (y) { return new event_return_1.default([y.lat(), y.lng()]); }); }));
+        });
+    };
+    GooglePolygons.prototype.addPolygonEventInsertAt = function (polygon, eventFunction) {
+        var polygonPathIdx = polygon.getPaths().getLength();
+        for (var index = 0; index < polygonPathIdx; index++) {
+            this.addPolygonEventInsertAtAllPaths(polygon, polygon.getPaths().getAt(index), eventFunction);
+        }
+    };
+    GooglePolygons.prototype.addPolygonEventInsertAtAllPaths = function (polygon, innerPolygon, eventFunction) {
+        this.google.maps.event.addListener(innerPolygon, 'insert_at', function (event) {
+            var newPath = innerPolygon.getAt(event);
+            var newPoint = new event_return_1.default([newPath.lat(), newPath.lng()]);
+            var previousPath = innerPolygon.getAt(event - 1);
+            var previousPoint = previousPath ? new event_return_1.default([previousPath.lat(), previousPath.lng()]) : null;
+            eventFunction(newPoint, previousPoint, polygon.object, event, polygon.getPaths().getArray().map(function (x) { return x.getArray().map(function (y) { return new event_return_1.default([y.lat(), y.lng()]); }); }));
+        });
+    };
+    GooglePolygons.prototype.addPolygonEventRemoveAt = function (polygon, eventFunction) {
+        var polygonPathIdx = polygon.getPaths().getLength();
+        for (var index = 0; index < polygonPathIdx; index++) {
+            this.addPolygonEventRemoveAtAllPaths(polygon, polygon.getPaths().getAt(index), eventFunction);
+        }
+    };
+    GooglePolygons.prototype.addPolygonEventRemoveAtAllPaths = function (polygon, innerPolygon, eventFunction) {
+        this.google.maps.event.addListener(innerPolygon, 'remove_at', function (event) {
+            var param = new event_return_1.default([innerPolygon.getAt(event).lat(), innerPolygon.getAt(event).lng()]);
+            eventFunction(param, polygon.getPaths().getArray().map(function (x) { return x.getArray().map(function (y) { return new event_return_1.default([y.lat(), y.lng()]); }); }), polygon.object);
+        });
+    };
+    GooglePolygons.prototype.addPolygonEventDragPolygon = function (polygon, eventFunction) {
+        this.google.maps.event.addListener(polygon, 'dragstart', function (event) {
+            polygon.dragging = true;
+        });
+        this.google.maps.event.addListener(polygon, 'dragend', function (event) {
+            polygon.dragging = false;
+            eventFunction(polygon.getPaths().getArray().map(function (x) { return x.getArray().map(function (y) { return new event_return_1.default([y.lat(), y.lng()]); }); }), polygon.object);
+        });
+    };
+    GooglePolygons.prototype.addPolygonEventClick = function (polygon, eventFunction) {
+        this.google.maps.event.addListener(polygon, 'click', function (event) {
+            var param = new event_return_1.default([event.latLng.lat(), event.latLng.lng()]);
+            eventFunction(param, polygon.object);
+        });
+    };
+    GooglePolygons.prototype.getPathRecursiveArray = function (path) {
+        var _this = this;
+        if (Array.isArray(path) && typeof path[0] !== 'number') {
+            return path.map(function (x) { return _this.getPathRecursiveArray(x); });
+        }
+        else
+            return { lat: path[0], lng: path[1] };
+    };
+    GooglePolygons.prototype.getPathPolylineArray = function (path) {
+        if (typeof path[0].lat === 'number') {
+            return path;
+        }
+        else if (typeof path[0][0].lat !== 'number') {
+            path = path[0];
+            return this.getPathPolylineArray(path);
+        }
+        else
+            return path;
+    };
     return GooglePolygons;
 }());
 exports.default = GooglePolygons;
@@ -4447,7 +4521,7 @@ var GooglePolylines = /** @class */ (function () {
         var _this = this;
         polylines.forEach(function (polyline) {
             switch (eventType) {
-                case event_type_1.PolylineEventType.Move:
+                case event_type_1.PolylineEventType.SetAt:
                     _this.addPolylineEventMove(polyline, eventFunction);
                     break;
                 case event_type_1.PolylineEventType.InsertAt:
@@ -4456,6 +4530,9 @@ var GooglePolylines = /** @class */ (function () {
                 case event_type_1.PolylineEventType.RemoveAt:
                     _this.addPolylineEventRemoveAt(polyline, eventFunction);
                     break;
+                case event_type_1.PolylineEventType.DragPolyline:
+                    _this.addPolylineEventDragPolyline(polyline, eventFunction);
+                    break;
                 default:
                     break;
             }
@@ -4463,12 +4540,10 @@ var GooglePolylines = /** @class */ (function () {
     };
     GooglePolylines.prototype.removePolylineEvent = function (polylines, event) {
         var _this = this;
-        polylines.forEach(function (polyline) {
-            return _this.google.maps.event.clearListeners(polyline, 'click');
-        });
+        polylines.forEach(function (polyline) { return _this.google.maps.event.clearListeners(polyline, 'click'); });
         polylines.forEach(function (polyline) {
             switch (event) {
-                case event_type_1.PolylineEventType.Move:
+                case event_type_1.PolylineEventType.SetAt:
                     _this.google.maps.event.clearListeners(polyline.getPath(), 'set_at');
                     break;
                 case event_type_1.PolylineEventType.InsertAt:
@@ -4477,6 +4552,10 @@ var GooglePolylines = /** @class */ (function () {
                 case event_type_1.PolylineEventType.RemoveAt:
                     _this.google.maps.event.clearListeners(polyline.getPath(), 'remove_at');
                     break;
+                case event_type_1.PolylineEventType.DragPolyline:
+                    _this.google.maps.event.clearListeners(polyline, 'dragstart');
+                    _this.google.maps.event.clearListeners(polyline, 'dragend');
+                    break;
                 default:
                     break;
             }
@@ -4669,10 +4748,12 @@ var GooglePolylines = /** @class */ (function () {
     };
     GooglePolylines.prototype.addPolylineEventMove = function (polyline, eventFunction) {
         polyline.moveListener = function (newEvent, lastEvent) {
+            if (polyline.dragging)
+                return;
             var path = polyline.getPath().getAt(newEvent);
             var newPosition = new event_return_1.default([path.lat(), path.lng()]);
             var lastPosition = new event_return_1.default([lastEvent.lat(), lastEvent.lng()]);
-            eventFunction(newPosition, lastPosition, polyline.object, newEvent);
+            eventFunction(newPosition, lastPosition, polyline.object, newEvent, polyline.getPath().getArray().map(function (x) { return new event_return_1.default([x.lat(), x.lng()]); }));
         };
         this.google.maps.event.addListener(polyline.getPath(), 'set_at', polyline.moveListener);
     };
@@ -4683,18 +4764,26 @@ var GooglePolylines = /** @class */ (function () {
             var newPoint = new event_return_1.default([newPath.lat(), newPath.lng()]);
             var previousPath = path.getAt(event - 1);
             var previousPoint = previousPath ? new event_return_1.default([previousPath.lat(), previousPath.lng()]) : null;
-            eventFunction(newPoint, previousPoint, polyline.object, event);
+            eventFunction(newPoint, previousPoint, polyline.object, event, polyline.getPath().getArray().map(function (x) { return new event_return_1.default([x.lat(), x.lng()]); }));
         };
         this.google.maps.event.addListener(polyline.getPath(), 'insert_at', polyline.insertAtListener);
     };
     GooglePolylines.prototype.addPolylineEventRemoveAt = function (polyline, eventFunction) {
         polyline.removeAtListener = function (event) {
-            var param = new event_return_1.default([polyline.getPath().getAt(event).lat(),
-                polyline.getPath().getAt(event).lng()]);
-            eventFunction(param);
+            var param = new event_return_1.default([polyline.getPath().getAt(event).lat(), polyline.getPath().getAt(event).lng()]);
+            eventFunction(param, polyline.object, polyline.getPath().getArray().map(function (x) { return new event_return_1.default([x.lat(), x.lng()]); }));
         };
         this.google.maps.event.addListener(polyline.getPath(), 'remove_at', polyline.removeAtListener);
     };
+    GooglePolylines.prototype.addPolylineEventDragPolyline = function (polyline, eventFunction) {
+        polyline.dragPolylineListener = function () {
+            polyline.dragging = false;
+            var param = polyline.getPath().getArray().map(function (x) { return new event_return_1.default([x.lat(), x.lng()]); });
+            eventFunction(param, polyline.object);
+        };
+        this.google.maps.event.addListener(polyline, 'dragend', polyline.dragPolylineListener);
+        this.google.maps.event.addListener(polyline, 'dragstart', function () { return polyline.dragging = true; });
+    };
     GooglePolylines.prototype.updateSelectedPathListeners = function () {
         if (this.selectedPath.moveListener) {
             this.google.maps.event.clearListeners(this.selectedPath.getPath(), 'set_at');
@@ -5910,12 +5999,10 @@ var LeafletPolygons = /** @class */ (function () {
             }
             polygon.setStyle(style);
             if (options.editable !== null && options.editable !== undefined) {
+                polygon.disableEdit();
                 if (options.editable) {
                     polygon.enableEdit();
                 }
-                else {
-                    polygon.disableEdit();
-                }
             }
             if (options.object) {
                 polygon.object = options.object;
@@ -5935,31 +6022,26 @@ var LeafletPolygons = /** @class */ (function () {
         return polygon.getLatLngs()[0].map(function (x) { return [x.lat, x.lng]; });
     };
     LeafletPolygons.prototype.addPolygonEvent = function (polygons, eventType, eventFunction) {
+        var _this = this;
         var self = this;
         polygons.forEach(function (polygon) {
             switch (eventType) {
-                case event_type_1.PolygonEventType.Move:
-                    polygon.on('dragend', function (event) {
-                        var param = new event_return_1.default([event.target.getCenter().lat, event.target.getCenter().lng]);
-                        eventFunction(param, event.target.getLatLngs()[0].map(function (x) { return [x.lat, x.lng]; }, event.target.object));
-                    });
+                case event_type_1.PolygonEventType.SetAt:
+                    _this.addPolygonEventMove(polygon, eventFunction);
                     break;
                 case event_type_1.PolygonEventType.InsertAt:
-                    polygon.on('editable:vertex:dragend', function (event) {
-                        var param = new event_return_1.default([event.vertex.latlng.lat, event.vertex.latlng.lng]);
-                        eventFunction(param, event.vertex.latlngs.map(function (x) { return [x.lat, x.lng]; }), event.target.object);
-                    });
-                    polygon.on('editable:vertex:clicked', function (event) {
-                        var param = new event_return_1.default([event.vertex.latlng.lat, event.vertex.latlng.lng]);
-                        eventFunction(param, event.vertex.latlngs.map(function (x) { return [x.lat, x.lng]; }), event.target.object);
-                    });
+                    _this.addPolygonEventInsertAt(polygon, eventFunction);
+                    break;
+                case event_type_1.PolygonEventType.RemoveAt:
+                    _this.addPolygonEventRemoveAt(polygon, eventFunction);
+                    break;
+                case event_type_1.PolygonEventType.DragPolygon:
+                    _this.addPolygonEventDragPolygon(polygon, eventFunction);
                     break;
                 case event_type_1.PolygonEventType.Click:
-                    polygon.on('click', function (event) {
-                        self.leaflet.DomEvent.stopPropagation(event);
-                        var param = new event_return_1.default([event.latlng.lat, event.latlng.lng]);
-                        eventFunction(param, event.target.object);
-                    });
+                    _this.addPolygonEventClick(polygon, eventFunction, self);
+                    break;
+                default:
                     break;
             }
         });
@@ -5967,11 +6049,18 @@ var LeafletPolygons = /** @class */ (function () {
     LeafletPolygons.prototype.removePolygonEvent = function (polygons, event) {
         polygons.forEach(function (polygon) {
             switch (event) {
-                case event_type_1.PolygonEventType.Move:
+                case event_type_1.PolygonEventType.SetAt:
                     polygon.off('editable:vertex:dragstart');
                     break;
                 case event_type_1.PolygonEventType.InsertAt:
-                    polygon.off('editable:vertex:dragend');
+                    polygon.off('editable:vertex:new');
+                    break;
+                case event_type_1.PolygonEventType.RemoveAt:
+                    polygon.off('editable:vertex:clicked');
+                    polygon.off('editable:vertex:deleted');
+                    break;
+                case event_type_1.PolygonEventType.DragPolygon:
+                    polygon.off('dragend');
                     break;
                 case event_type_1.PolygonEventType.Click:
                     polygon.off('click');
@@ -5983,6 +6072,80 @@ var LeafletPolygons = /** @class */ (function () {
         var group = new this.leaflet.FeatureGroup(polygons);
         return group.getBounds();
     };
+    LeafletPolygons.prototype.addPolygonEventMove = function (polygon, eventFunction) {
+        polygon.on('editable:vertex:dragstart', function (eventStart) {
+            var lastPosition = new event_return_1.default([eventStart.vertex.latlng.lat, eventStart.vertex.latlng.lng]);
+            polygon.on('editable:vertex:dragend', function (eventEnd) {
+                var newPosition = new event_return_1.default([eventEnd.vertex.latlng.lat, eventEnd.vertex.latlng.lng]);
+                var path = polygon.getLatLngs().map(function (x) {
+                    if (Array.isArray(x[0])) {
+                        return x.map(function (y) { return y.map(function (z) { return new event_return_1.default([z.lat, z.lng]); }); });
+                    }
+                    else {
+                        return [x.map(function (y) { return new event_return_1.default([y.lat, y.lng]); })];
+                    }
+                });
+                eventFunction(newPosition, lastPosition, eventEnd.target.object, eventEnd.vertex.getIndex(), path[0]);
+                polygon.off('editable:vertex:dragend');
+            });
+        });
+    };
+    LeafletPolygons.prototype.addPolygonEventInsertAt = function (polygon, eventFunction) {
+        polygon.on('editable:vertex:new', function (eventNew) {
+            var latlngs = eventNew.vertex.latlngs;
+            var previous = latlngs[latlngs.findIndex(function (x) { return x === eventNew.vertex.latlng; }) - 1];
+            if (previous) {
+                var previousPoint_1 = new event_return_1.default([previous.lat, previous.lng]);
+                polygon.on('editable:vertex:dragend', function (event) {
+                    var newPoint = new event_return_1.default([event.vertex.latlng.lat, event.vertex.latlng.lng]);
+                    var path = polygon.getLatLngs().map(function (x) {
+                        if (Array.isArray(x[0])) {
+                            return x.map(function (y) { return y.map(function (z) { return new event_return_1.default([z.lat, z.lng]); }); });
+                        }
+                        else {
+                            return [x.map(function (y) { return new event_return_1.default([y.lat, y.lng]); })];
+                        }
+                    });
+                    eventFunction(newPoint, previousPoint_1, event.target.object, event.vertex.getIndex(), path[0]);
+                    polygon.off('editable:vertex:dragend');
+                });
+            }
+        });
+    };
+    LeafletPolygons.prototype.addPolygonEventRemoveAt = function (polygon, eventFunction) {
+        polygon.on('editable:vertex:deleted', function (event) {
+            var param = new event_return_1.default([event.vertex.latlng.lat, event.vertex.latlng.lng]);
+            var path = polygon.getLatLngs().map(function (x) {
+                if (Array.isArray(x[0])) {
+                    return x.map(function (y) { return y.map(function (z) { return new event_return_1.default([z.lat, z.lng]); }); });
+                }
+                else {
+                    return [x.map(function (y) { return new event_return_1.default([y.lat, y.lng]); })];
+                }
+            });
+            eventFunction(param, path[0], event.target.object);
+        });
+    };
+    LeafletPolygons.prototype.addPolygonEventDragPolygon = function (polygon, eventFunction) {
+        polygon.on('dragend', function (event) {
+            var path = polygon.getLatLngs().map(function (x) {
+                if (Array.isArray(x[0])) {
+                    return x.map(function (y) { return y.map(function (z) { return new event_return_1.default([z.lat, z.lng]); }); });
+                }
+                else {
+                    return [x.map(function (y) { return new event_return_1.default([y.lat, y.lng]); })];
+                }
+            });
+            eventFunction(path[0], event.target.object);
+        });
+    };
+    LeafletPolygons.prototype.addPolygonEventClick = function (polygon, eventFunction, self) {
+        polygon.on('click', function (event) {
+            self.leaflet.DomEvent.stopPropagation(event);
+            var param = new event_return_1.default([event.latlng.lat, event.latlng.lng]);
+            eventFunction(param, event.target.object);
+        });
+    };
     return LeafletPolygons;
 }());
 exports.default = LeafletPolygons;
@@ -6044,6 +6207,11 @@ var LeafletPolylines = /** @class */ (function () {
                 var param = new event_return_1.default([event.latlng.lat, event.latlng.lng]);
                 eventClick(param, event.target.object);
             });
+            polyline.on('editable:vertex:rawclick', function (event) {
+                event.cancel();
+                var param = new event_return_1.default([event.latlng.lat, event.latlng.lng]);
+                eventClick(param, event.target.object);
+            });
         }
         if (options.style && options.style === polyline_type_1.PolylineType.Arrow) {
             var pathOptions = { fillOpacity: 1, weight: 0, color: polyline.options.color };
@@ -6200,7 +6368,7 @@ var LeafletPolylines = /** @class */ (function () {
         var _this = this;
         polylines.forEach(function (polyline) {
             switch (eventType) {
-                case event_type_1.PolylineEventType.Move:
+                case event_type_1.PolylineEventType.SetAt:
                     _this.addPolylineEventMove(polyline, eventFunction);
                     break;
                 case event_type_1.PolylineEventType.InsertAt:
@@ -6209,6 +6377,9 @@ var LeafletPolylines = /** @class */ (function () {
                 case event_type_1.PolylineEventType.RemoveAt:
                     _this.addPolylineEventRemoveAt(polyline, eventFunction);
                     break;
+                case event_type_1.PolylineEventType.DragPolyline:
+                    _this.addPolylineEventDragPolyline(polyline, eventFunction);
+                    break;
                 default:
                     break;
             }
@@ -6217,16 +6388,18 @@ var LeafletPolylines = /** @class */ (function () {
     LeafletPolylines.prototype.removePolylineEvent = function (polylines, event) {
         polylines.forEach(function (polyline) {
             switch (event) {
-                case event_type_1.PolylineEventType.Move:
-                    polyline.off('editable:vertex:dragend');
+                case event_type_1.PolylineEventType.SetAt:
+                    polyline.off('editable:vertex:dragstart');
                     break;
                 case event_type_1.PolylineEventType.InsertAt:
                     polyline.off('editable:vertex:new');
-                    polyline.off('editable:vertex:dragend');
                     break;
                 case event_type_1.PolylineEventType.RemoveAt:
                     polyline.off('editable:vertex:deleted');
                     break;
+                case event_type_1.PolylineEventType.DragPolyline:
+                    polyline.off('dragend');
+                    break;
                 default:
                     break;
             }
@@ -6495,7 +6668,7 @@ var LeafletPolylines = /** @class */ (function () {
                     self.setArrowSelectedPath();
                 }
                 var newPosition = new event_return_1.default([eventEnd.vertex.latlng.lat, eventEnd.vertex.latlng.lng]);
-                eventFunction(newPosition, lastPosition, eventEnd.target.object, eventEnd.vertex.getIndex());
+                eventFunction(newPosition, lastPosition, eventEnd.target.object, eventEnd.vertex.getIndex(), polyline.getLatLngs().map(function (x) { return new event_return_1.default([x.lat, x.lng]); }));
                 polyline.off('editable:vertex:dragend');
             });
         });
@@ -6512,7 +6685,7 @@ var LeafletPolylines = /** @class */ (function () {
                     self.setArrowSelectedPath();
                 }
                 var newPoint = new event_return_1.default([event.vertex.latlng.lat, event.vertex.latlng.lng]);
-                eventFunction(newPoint, previousPoint, event.target.object, event.vertex.getIndex());
+                eventFunction(newPoint, previousPoint, event.target.object, event.vertex.getIndex(), polyline.getLatLngs().map(function (x) { return new event_return_1.default([x.lat, x.lng]); }));
                 polyline.off('editable:vertex:dragend');
             });
         });
@@ -6520,7 +6693,13 @@ var LeafletPolylines = /** @class */ (function () {
     LeafletPolylines.prototype.addPolylineEventRemoveAt = function (polyline, eventFunction) {
         polyline.on('editable:vertex:deleted', function (event) {
             var param = new event_return_1.default([event.vertex.latlng.lat, event.vertex.latlng.lng]);
-            eventFunction(param);
+            eventFunction(param, event.target.object, polyline.getLatLngs().map(function (x) { return new event_return_1.default([x.lat, x.lng]); }));
+        });
+    };
+    LeafletPolylines.prototype.addPolylineEventDragPolyline = function (polyline, eventFunction) {
+        polyline.on('dragend', function (event) {
+            var param = event.target.getLatLngs().map(function (x) { return new event_return_1.default([x.lat, x.lng]); });
+            eventFunction(param, event.target.object);
         });
     };
     return LeafletPolylines;