@nextgis/leaflet-map-adapter 1.18.1 → 1.18.6

package/lib/leaflet-map-adapter.global.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/leaflet-map-adapter; version: 1.18.1; author: NextGIS */
+/** Bundle of @nextgis/leaflet-map-adapter; version: 1.18.6; author: NextGIS */
 var LeafletMapAdapter = (function () {
     'use strict';
 
@@ -14801,19 +14801,6 @@ var LeafletMapAdapter = (function () {
         return wrapper;
     }
 
-    function isPaint(paint) {
-        if (Object.prototype.toString.call(paint) === '[object Object]') {
-            return true;
-        }
-        return false;
-    }
-    function isPaintCallback(paint) {
-        if (typeof paint === 'function') {
-            return true;
-        }
-        return false;
-    }
-
     function boundsToArray(bounds) {
         var ne = bounds.getNorthEast();
         var sw = bounds.getSouthWest();
@@ -14885,14 +14872,6 @@ var LeafletMapAdapter = (function () {
         };
     }
 
-    function createMouseEvent(_a) {
-        var layer = _a.layer, source = _a.source;
-        var layer_ = source.target;
-        var feature = layer_.feature;
-        var opt = __assign({ layer: layer, feature: feature, event: convertMapClickEvent(source), source: source }, createFeaturePositionOptions(feature));
-        return opt;
-    }
-
     function findMostFrequentGeomType(arr) {
         var counts = {};
         for (var fry = 0; fry < arr.length; fry++) {
@@ -14948,6 +14927,208 @@ var LeafletMapAdapter = (function () {
         return BaseAdapter;
     }());
 
+    function createMouseEvent(_a) {
+        var layer = _a.layer, source = _a.source;
+        var layer_ = source.target;
+        var feature = layer_.feature;
+        var opt = __assign({ layer: layer, feature: feature, event: convertMapClickEvent(source), source: source }, createFeaturePositionOptions(feature));
+        return opt;
+    }
+
+    var GeoJsonEvents = /** @class */ (function () {
+        function GeoJsonEvents(layer) {
+            this.layer = layer;
+        }
+        GeoJsonEvents.prototype.handleMouseEvents = function (layer) {
+            var _this = this;
+            var _a = this.layer.options, onClick = _a.onClick, onLayerClick = _a.onLayerClick, onMouseOut = _a.onMouseOut, onMouseOver = _a.onMouseOver;
+            // TODO: remove backward compatibility for onLayerClick
+            var onClick_ = onClick || onLayerClick;
+            if (onClick_) {
+                this._onclick = function (e) {
+                    var selected = !!_this.layer._getSelected(layer);
+                    onClick_(__assign({ selected: selected }, _this._createMouseEvent(e)));
+                };
+                layer.on('click', this._onclick, this);
+            }
+            if (onMouseOut) {
+                this._mouseout = function (e) {
+                    onMouseOut(_this._createMouseEvent(e));
+                };
+                layer.on('mouseout', this._mouseout, this);
+            }
+            if (onMouseOver) {
+                this._mouseover = function (e) {
+                    onMouseOver(_this._createMouseEvent(e));
+                };
+                layer.on('mouseover', this._mouseover, this);
+            }
+        };
+        GeoJsonEvents.prototype.stopMouseEvents = function (layer) {
+            if (this._mouseover) {
+                layer.off('mouseover', this._mouseover, this);
+            }
+            if (this._mouseout) {
+                layer.off('mouseout', this._mouseout, this);
+            }
+            if (this._onclick) {
+                layer.off('click', this._onclick, this);
+            }
+        };
+        GeoJsonEvents.prototype._createMouseEvent = function (source) {
+            return createMouseEvent({
+                layer: this.layer,
+                source: source,
+            });
+        };
+        return GeoJsonEvents;
+    }());
+
+    function isPaint(paint) {
+        if (Object.prototype.toString.call(paint) === '[object Object]') {
+            return true;
+        }
+        return false;
+    }
+    function isPaintCallback(paint) {
+        if (typeof paint === 'function') {
+            return true;
+        }
+        return false;
+    }
+
+    var GeoJsonPaint = /** @class */ (function () {
+        function GeoJsonPaint(layer) {
+            this.layer = layer;
+        }
+        GeoJsonPaint.prototype.setPaintEachLayer = function (paint) {
+            var _this = this;
+            this.layer._layers.forEach(function (layerDef) {
+                _this.setPaint(layerDef, paint);
+            });
+        };
+        GeoJsonPaint.prototype.setPaint = function (layerDef, paint) {
+            var style = undefined;
+            var layer = layerDef.layer, feature = layerDef.feature;
+            if (layer && feature) {
+                if (isPaintCallback(paint)) {
+                    style = paint(feature);
+                }
+                else if (isPaint(paint)) {
+                    style = paint;
+                }
+                if (style) {
+                    if (this.layer.type === 'point' && style.type === 'icon') {
+                        var marker_1 = layer;
+                        var divIcon_1 = this._createDivIcon(style);
+                        setTimeout(function () {
+                            marker_1.setIcon(divIcon_1);
+                        }, 10);
+                    }
+                    else if ('setStyle' in layer) {
+                        layer.setStyle(this.preparePaint(style));
+                    }
+                }
+            }
+        };
+        GeoJsonPaint.prototype.preparePaint = function (paint) {
+            if (paint.type !== 'get-paint') {
+                var paintAliases = [
+                    ['color', 'strokeColor'],
+                    ['opacity', 'strokeOpacity'],
+                    ['stroke', 'stroke'],
+                    ['fillColor', 'fillColor'],
+                    ['fillOpacity', 'fillOpacity'],
+                    ['fill', 'fill'],
+                    ['weight', 'weight'],
+                ];
+                var aliases = this.layer.type === 'line'
+                    ? [
+                        ['color', 'strokeColor'],
+                        ['opacity', 'strokeOpacity'],
+                        ['weight', 'weight'],
+                    ]
+                    : paintAliases;
+                var readyPaint = {};
+                if ('radius' in paint && typeof paint.radius === 'number') {
+                    readyPaint.radius = paint.radius;
+                }
+                for (var _i = 0, aliases_1 = aliases; _i < aliases_1.length; _i++) {
+                    var _a = aliases_1[_i], to = _a[0], from = _a[1];
+                    var opacity = this.layer.options.opacity;
+                    var paintProp = paint[from];
+                    if (defined(opacity) && from.toLowerCase().indexOf('opacity') !== -1) {
+                        paintProp = Number(paintProp) * opacity;
+                    }
+                    if (paintProp !== undefined) {
+                        Object.defineProperty(readyPaint, to, {
+                            enumerable: true,
+                            value: paintProp,
+                        });
+                    }
+                }
+                return readyPaint;
+            }
+            return PAINT;
+        };
+        GeoJsonPaint.prototype._createDivIcon = function (icon) {
+            var html = icon.html, rotate = icon.rotate, className = icon.className, toLIconOpt = __rest(icon, ["html", "rotate", "className"]);
+            var element = document.createElement('div');
+            if (className) {
+                element.className = className;
+            }
+            if (rotate) {
+                element.style.transform = "rotateZ(".concat(rotate, "deg)");
+            }
+            if (html) {
+                element.innerHTML = html;
+            }
+            var divIcon = new leafletSrc.exports.DivIcon(__assign(__assign({ className: '' }, toLIconOpt), { html: element }));
+            return divIcon;
+        };
+        GeoJsonPaint.prototype.createPaintToLayer = function (icon) {
+            var _this = this;
+            if (icon && icon.type) {
+                if (icon.type === 'icon') {
+                    var iconClassName = icon.className;
+                    var html = icon.html;
+                    if (iconClassName || html) {
+                        return function (_, latlng) {
+                            var divIcon = _this._createDivIcon(icon);
+                            return new leafletSrc.exports.Marker(latlng, { icon: divIcon });
+                        };
+                    }
+                }
+                else if (icon.type === 'pin') {
+                    return function (_, latlng) {
+                        return new leafletSrc.exports.Marker(latlng);
+                    };
+                }
+            }
+            return function (_, latlng) {
+                var p = PAINT;
+                return new leafletSrc.exports.CircleMarker(latlng, _this.preparePaint(__assign(__assign({}, p), icon)));
+            };
+        };
+        GeoJsonPaint.prototype.createPaintOptions = function (paint) {
+            var geoJsonOptions = {};
+            var newPaint = this.preparePaint(paint);
+            if (paint) {
+                geoJsonOptions.style = function () {
+                    return newPaint;
+                };
+            }
+            if (this.layer.type === 'point') {
+                geoJsonOptions.pointToLayer = this.createPaintToLayer(paint);
+            }
+            else if (this.layer.type === 'line') {
+                newPaint.stroke = true;
+            }
+            return geoJsonOptions;
+        };
+        return GeoJsonPaint;
+    }());
+
     var GeoJsonAdapter = /** @class */ (function (_super) {
         __extends(GeoJsonAdapter, _super);
         function GeoJsonAdapter(map, options) {
@@ -14963,6 +15144,8 @@ var LeafletMapAdapter = (function () {
             _this.$unselect = function () {
                 _this.unselect();
             };
+            _this._events = new GeoJsonEvents(_this);
+            _this._paint = new GeoJsonPaint(_this);
             return _this;
         }
         GeoJsonAdapter.prototype.addLayer = function (options) {
@@ -14992,7 +15175,7 @@ var LeafletMapAdapter = (function () {
             else if (!this.selected) {
                 this.selected = true;
                 if (this.selectedPaint) {
-                    this._setPaintEachLayer(this.selectedPaint);
+                    this._paint.setPaintEachLayer(this.selectedPaint);
                 }
             }
         };
@@ -15010,7 +15193,7 @@ var LeafletMapAdapter = (function () {
                     this._removePopup(p[0]);
                 }
                 if (this.paint) {
-                    this._setPaintEachLayer(this.paint);
+                    this._paint.setPaintEachLayer(this.paint);
                 }
                 this._selectedLayers.length = 0;
                 this.selected = false;
@@ -15171,7 +15354,7 @@ var LeafletMapAdapter = (function () {
                 this.paint = paint;
                 for (var _i = 0, _a = this._layers; _i < _a.length; _i++) {
                     var l = _a[_i];
-                    this._setPaint(l, paint);
+                    this._paint.setPaint(l, paint);
                 }
             }
         };
@@ -15180,7 +15363,7 @@ var LeafletMapAdapter = (function () {
                 this.selectedPaint = paint;
                 for (var _i = 0, _a = this._selectedLayers; _i < _a.length; _i++) {
                     var l = _a[_i];
-                    this._setPaint(l, paint);
+                    this._paint.setPaint(l, paint);
                 }
             }
         };
@@ -15188,16 +15371,19 @@ var LeafletMapAdapter = (function () {
             this.paint = __assign(__assign({}, this.paint), paint);
             for (var _i = 0, _a = this._layers; _i < _a.length; _i++) {
                 var l = _a[_i];
-                this._setPaint(l, this.paint);
+                this._paint.setPaint(l, this.paint);
             }
         };
         GeoJsonAdapter.prototype.updateSelectedPaint = function (paint) {
             this.selectedPaint = __assign(__assign({}, this.selectedPaint), paint);
             for (var _i = 0, _a = this._selectedLayers; _i < _a.length; _i++) {
                 var l = _a[_i];
-                this._setPaint(l, this.selectedPaint);
+                this._paint.setPaint(l, this.selectedPaint);
             }
         };
+        GeoJsonAdapter.prototype._getSelected = function (layer) {
+            return this._selectedLayers.find(function (x) { return x.layer === layer; });
+        };
         GeoJsonAdapter.prototype._updateTooltip = function (layerDef) {
             var feature = layerDef.feature, layer = layerDef.layer;
             if (feature && layer && feature.properties && this.options.labelField) {
@@ -15289,79 +15475,6 @@ var LeafletMapAdapter = (function () {
                 }
             }
         };
-        GeoJsonAdapter.prototype._setPaintEachLayer = function (paint) {
-            var _this = this;
-            this._layers.forEach(function (l) {
-                _this._setPaint(l, paint);
-            });
-        };
-        GeoJsonAdapter.prototype._setPaint = function (def, paint) {
-            var style = undefined;
-            var layer = def.layer, feature = def.feature;
-            if (layer && feature) {
-                if (isPaintCallback(paint)) {
-                    style = paint(feature);
-                }
-                else if (isPaint(paint)) {
-                    style = paint;
-                }
-                if (style) {
-                    if (this.type === 'point' && style.type === 'icon') {
-                        var marker = layer;
-                        var divIcon = this._createDivIcon(style);
-                        marker.setIcon(divIcon);
-                    }
-                    else if ('setStyle' in layer) {
-                        layer.setStyle(this._preparePaint(style));
-                    }
-                }
-            }
-        };
-        GeoJsonAdapter.prototype._preparePaint = function (paint) {
-            if (paint.type !== 'get-paint') {
-                // const path: CircleMarkerOptions | PathOptions = paint as CircleMarkerOptions | PathOptions;
-                // if (path.opacity) {
-                //   path.fillOpacity = path.opacity;
-                // }
-                var paintAliases = [
-                    // ['color', 'color'],
-                    ['color', 'strokeColor'],
-                    ['opacity', 'strokeOpacity'],
-                    ['stroke', 'stroke'],
-                    ['fillColor', 'fillColor'],
-                    ['fillOpacity', 'fillOpacity'],
-                    ['fill', 'fill'],
-                    ['weight', 'weight'],
-                ];
-                var aliases = this.type === 'line'
-                    ? [
-                        ['color', 'strokeColor'],
-                        ['opacity', 'strokeOpacity'],
-                        ['weight', 'weight'],
-                    ]
-                    : paintAliases;
-                var readyPaint = {};
-                if ('radius' in paint && typeof paint.radius === 'number') {
-                    readyPaint.radius = paint.radius;
-                }
-                for (var _i = 0, aliases_1 = aliases; _i < aliases_1.length; _i++) {
-                    var _a = aliases_1[_i], to = _a[0], from = _a[1];
-                    var paintProp = paint[from];
-                    if (defined(this.options.opacity) &&
-                        from.toLowerCase().indexOf('opacity') !== -1) {
-                        paintProp = Number(paintProp) * this.options.opacity;
-                    }
-                    if (paintProp !== undefined) {
-                        Object.defineProperty(readyPaint, to, {
-                            enumerable: true,
-                            value: paintProp,
-                        });
-                    }
-                }
-                return readyPaint;
-            }
-            return PAINT;
-        };
         GeoJsonAdapter.prototype._getGeoJsonOptions = function (options, type) {
             var _this = this;
             var paint = options.paint;
@@ -15371,7 +15484,7 @@ var LeafletMapAdapter = (function () {
                     // TODO: fix types (@geoman-io/leaflet-geoman-free)
                     lopt.pointToLayer = function (feature, latLng) {
                         var iconOpt = paint(feature);
-                        var pointToLayer = _this._createPaintToLayer(iconOpt);
+                        var pointToLayer = _this._paint.createPaintToLayer(iconOpt);
                         return pointToLayer(feature, latLng);
                     };
                 }
@@ -15379,17 +15492,17 @@ var LeafletMapAdapter = (function () {
                     lopt = {
                         style: function (feature) {
                             if (feature) {
-                                return _this._preparePaint(__assign(__assign({}, PAINT), paint(feature)));
+                                return _this._paint.preparePaint(__assign(__assign({}, PAINT), paint(feature)));
                             }
                             else {
-                                return _this._preparePaint(__assign(__assign({}, PAINT), { type: 'path' }));
+                                return _this._paint.preparePaint(__assign(__assign({}, PAINT), { type: 'path' }));
                             }
                         },
                     };
                 }
             }
             else {
-                lopt = this._createPaintOptions(paint, type);
+                lopt = this._paint.createPaintOptions(paint);
             }
             lopt.onEachFeature = function (feature, layer) {
                 _this._onEachFeature(feature, layer);
@@ -15401,7 +15514,6 @@ var LeafletMapAdapter = (function () {
             var layer_ = this.layer;
             if (layer_) {
                 var def_2 = __assign({ target: this, feature: feature, layer: layer }, createFeaturePositionOptions(feature));
-                // @ts-ignore
                 layer.options.pane = this.pane;
                 this._layers.push(def_2);
                 var ok = true;
@@ -15426,7 +15538,7 @@ var LeafletMapAdapter = (function () {
                             layer.on('click', function (e) { return _this._selectOnLayerClick(e); }, this);
                         }
                     }
-                    this._handleMouseEvents(layer);
+                    this._events.handleMouseEvents(layer);
                     // The timeout is needed to display the popup immediately when adding a layer to the map.
                     // Without a timeout, the layer may not yet have a _map object
                     setTimeout(function () {
@@ -15438,37 +15550,6 @@ var LeafletMapAdapter = (function () {
                 }
             }
         };
-        GeoJsonAdapter.prototype._handleMouseEvents = function (layer) {
-            var _this = this;
-            var _a = this.options, onClick = _a.onClick, onLayerClick = _a.onLayerClick, onMouseOut = _a.onMouseOut, onMouseOver = _a.onMouseOver;
-            // TODO: remove backward compatibility for onLayerClick
-            var onClick_ = onClick || onLayerClick;
-            if (onClick_) {
-                layer.on('click', function (e) {
-                    var selected = !!_this._getSelected(layer);
-                    onClick_(__assign({ selected: selected }, _this._createMouseEvent(e)));
-                }, this);
-            }
-            if (onMouseOut) {
-                layer.on('mouseout', function (e) {
-                    onMouseOut(_this._createMouseEvent(e));
-                }, this);
-            }
-            if (onMouseOver) {
-                layer.on('mouseover', function (e) {
-                    onMouseOver(_this._createMouseEvent(e));
-                }, this);
-            }
-        };
-        GeoJsonAdapter.prototype._createMouseEvent = function (source) {
-            return createMouseEvent({
-                layer: this,
-                source: source,
-            });
-        };
-        GeoJsonAdapter.prototype._getSelected = function (layer) {
-            return this._selectedLayers.find(function (x) { return x.layer === layer; });
-        };
         GeoJsonAdapter.prototype._selectOnLayerClick = function (e) {
             leafletSrc.exports.DomEvent.stopPropagation(e);
             var layer = e.target;
@@ -15498,7 +15579,7 @@ var LeafletMapAdapter = (function () {
             this.selected = true;
             var _a = this.options, selectedPaint = _a.selectedPaint, popupOnSelect = _a.popupOnSelect, popupOptions = _a.popupOptions;
             if (selectedPaint && def.layer) {
-                this._setPaint(def, selectedPaint);
+                this._paint.setPaint(def, selectedPaint);
             }
             if (popupOnSelect) {
                 this._openPopup(def, popupOptions, type, latlng);
@@ -15514,7 +15595,7 @@ var LeafletMapAdapter = (function () {
                 this._selectedLayers.splice(index, 1);
                 if (this.options) {
                     if (this.options.paint) {
-                        this._setPaint(def, this.options.paint);
+                        this._paint.setPaint(def, this.options.paint);
                     }
                     if (this.options.popupOnSelect && def.layer) {
                         this._removePopup(def.layer);
@@ -15523,51 +15604,6 @@ var LeafletMapAdapter = (function () {
             }
             this.selected = this._selectedLayers.length > 0;
         };
-        GeoJsonAdapter.prototype._createDivIcon = function (icon) {
-            var toLIconOpt = __rest(icon, []);
-            return new leafletSrc.exports.DivIcon(__assign({ className: '' }, toLIconOpt));
-        };
-        GeoJsonAdapter.prototype._createPaintToLayer = function (icon) {
-            var _this = this;
-            if (icon && icon.type) {
-                if (icon.type === 'icon') {
-                    var iconClassName = icon.className;
-                    var html = icon.html;
-                    if (iconClassName || html) {
-                        return function (geoJsonPoint, latlng) {
-                            var divIcon = _this._createDivIcon(icon);
-                            return new leafletSrc.exports.Marker(latlng, { icon: divIcon });
-                        };
-                    }
-                }
-                else if (icon.type === 'pin') {
-                    return function (geoJsonPoint, latlng) {
-                        // const divIcon = this.createDivIcon(icon);
-                        return new leafletSrc.exports.Marker(latlng);
-                    };
-                }
-            }
-            return function (geoJsonPoint, latlng) {
-                var p = PAINT;
-                return new leafletSrc.exports.CircleMarker(latlng, _this._preparePaint(__assign(__assign({}, p), icon)));
-            };
-        };
-        GeoJsonAdapter.prototype._createPaintOptions = function (paintOptions, type) {
-            var geoJsonOptions = {};
-            var paint = (paintOptions && this._preparePaint(paintOptions)) || {};
-            if (paintOptions) {
-                geoJsonOptions.style = function () {
-                    return paint;
-                };
-            }
-            if (type === 'point') {
-                geoJsonOptions.pointToLayer = this._createPaintToLayer(paintOptions);
-            }
-            else if (type === 'line') {
-                paint.stroke = true;
-            }
-            return geoJsonOptions;
-        };
         GeoJsonAdapter.prototype._addMapClickListener = function () {
             var map = this.map;
             if (map) {