@progress/kendo-charts 2.7.2-dev.202502101310 → 2.7.2-develop.1

package/dist/es/map/layers/shape.js

@@ -26,11 +26,11 @@ import {
     Location
 } from '../location';
 
-var Group = d.Group;
+const Group = d.Group;
 
-export var ShapeLayer = (function (Layer) {
-    function ShapeLayer(map, options) {
-        Layer.call(this, map, options);
+export class ShapeLayer extends Layer {
+    constructor(map, options) {
+        super(map, options);
 
         this._pan = proxy(this._pan, this);
 
@@ -50,18 +50,14 @@ export var ShapeLayer = (function (Layer) {
         this.surface.bind('mouseenter', this._mouseenter.bind(this));
     }
 
-    if ( Layer ) ShapeLayer.__proto__ = Layer;
-    ShapeLayer.prototype = Object.create( Layer && Layer.prototype );
-    ShapeLayer.prototype.constructor = ShapeLayer;
-
-    ShapeLayer.prototype.destroy = function destroy () {
-        Layer.prototype.destroy.call(this);
+    destroy() {
+        super.destroy();
 
         this.surface.destroy();
-    };
+    }
 
-    ShapeLayer.prototype._reset = function _reset () {
-        Layer.prototype._reset.call(this);
+    _reset() {
+        super._reset();
 
         this._translateSurface();
 
@@ -70,24 +66,24 @@ export var ShapeLayer = (function (Layer) {
         if (this._hasData()) {
             this._load(this._data);
         }
-    };
+    }
 
-    ShapeLayer.prototype._initRoot = function _initRoot () {
+    _initRoot() {
         this._root = new Group();
         this.surface.draw(this._root);
-    };
+    }
 
-    ShapeLayer.prototype._beforeReset = function _beforeReset () {
+    _beforeReset() {
         this.surface.clear();
         this._initRoot();
-    };
+    }
 
-    ShapeLayer.prototype._resize = function _resize () {
+    _resize() {
         this.surface.size(this.map.size());
-    };
+    }
 
-    ShapeLayer.prototype._readData = function _readData () {
-        var data = Layer.prototype._readData.call(this);
+    _readData() {
+        const data = super._readData();
 
         if (data.type === "FeatureCollection") {
             return data.features;
@@ -98,11 +94,9 @@ export var ShapeLayer = (function (Layer) {
         }
 
         return data;
-    };
-
-    ShapeLayer.prototype._load = function _load (data) {
-        var this$1 = this;
+    }
 
+    _load(data) {
         this._data = data;
         this._clearMarkers();
 
@@ -110,10 +104,10 @@ export var ShapeLayer = (function (Layer) {
             this._loader = new GeoJsonLoader(this.map, this.options.style, this);
         }
 
-        var container = new Group();
+        let container = new Group();
 
-        for (var i = 0; i < data.length; i++) {
-            var shape = this$1._loader.parse(data[i]);
+        for (let i = 0; i < data.length; i++) {
+            let shape = this._loader.parse(data[i]);
 
             if (shape) {
                 container.append(shape);
@@ -122,10 +116,10 @@ export var ShapeLayer = (function (Layer) {
 
         this._root.clear();
         this._root.append(container);
-    };
+    }
 
-    ShapeLayer.prototype.shapeCreated = function shapeCreated (shape) {
-        var cancelled = false;
+    shapeCreated(shape) {
+        let cancelled = false;
 
         // the GeoJSON loader builds "Point" type as a circle
         // use the circle shape type as and indicator for rendering a marker
@@ -136,7 +130,7 @@ export var ShapeLayer = (function (Layer) {
         }
 
         if (!cancelled) {
-            var args = {
+            let args = {
                 layer: this,
                 shape: shape
             };
@@ -145,15 +139,15 @@ export var ShapeLayer = (function (Layer) {
         }
 
         return cancelled;
-    };
+    }
 
-    ShapeLayer.prototype.featureCreated = function featureCreated (e) {
+    featureCreated(e) {
         e.layer = this;
         this.map.trigger('shapeFeatureCreated', e);
-    };
+    }
 
-    ShapeLayer.prototype._createMarker = function _createMarker (shape) {
-        var marker = this.map.markers.bind({
+    _createMarker(shape) {
+        let marker = this.map.markers.bind({
             location: shape.location
         }, shape.dataItem);
 
@@ -162,35 +156,33 @@ export var ShapeLayer = (function (Layer) {
         }
 
         return marker;
-    };
-
-    ShapeLayer.prototype._clearMarkers = function _clearMarkers () {
-        var this$1 = this;
+    }
 
-        for (var i = 0; i < this._markers.length; i++) {
-            this$1.map.markers.remove(this$1._markers[i]);
+    _clearMarkers() {
+        for (let i = 0; i < this._markers.length; i++) {
+            this.map.markers.remove(this._markers[i]);
         }
 
         this._markers = [];
-    };
+    }
 
-    ShapeLayer.prototype._pan = function _pan () {
+    _pan() {
         if (!this._panning) {
             this._panning = true;
             this.surface.suspendTracking();
         }
-    };
+    }
 
-    ShapeLayer.prototype._panEnd = function _panEnd (e) {
-        Layer.prototype._panEnd.call(this, e);
+    _panEnd(e) {
+        super._panEnd(e);
         this._translateSurface();
         this.surface.resumeTracking();
         this._panning = false;
-    };
+    }
 
-    ShapeLayer.prototype._translateSurface = function _translateSurface () {
-        var map = this.map;
-        var nw = map.locationToView(map.extent().nw);
+    _translateSurface() {
+        let map = this.map;
+        let nw = map.locationToView(map.extent().nw);
 
         if (this.surface.translate) {
             this.surface.translate(nw);
@@ -199,9 +191,9 @@ export var ShapeLayer = (function (Layer) {
                 y: nw.y
             });
         }
-    };
+    }
 
-    ShapeLayer.prototype._eventArgs = function _eventArgs (e) {
+    _eventArgs(e) {
         return {
             layer: this,
             layerIndex: this._layerIndex(),
@@ -209,31 +201,29 @@ export var ShapeLayer = (function (Layer) {
             shapeIndex: (this._data || []).indexOf(e.element.dataItem),
             originalEvent: e.originalEvent
         };
-    };
-
-    ShapeLayer.prototype._handler = function _handler (eventName) {
-        var this$1 = this;
+    }
 
-        return function (e) {
+    _handler(eventName) {
+        return (e) => {
             if (e.element) {
-                this$1.map.trigger(eventName, this$1._eventArgs(e));
+                this.map.trigger(eventName, this._eventArgs(e));
             }
         };
-    };
+    }
 
-    ShapeLayer.prototype._mouseenter = function _mouseenter (e) {
+    _mouseenter(e) {
         if (!e.element) {
             return;
         }
 
         this.map.trigger('shapeMouseEnter', this._eventArgs(e));
 
-        var shape = e.element;
-        var anchor = this._tooltipAnchor(e);
+        const shape = e.element;
+        const anchor = this._tooltipAnchor(e);
         this.map._tooltip.show(anchor, this._tooltipContext(shape));
-    };
+    }
 
-    ShapeLayer.prototype._tooltipContext = function _tooltipContext (shape) {
+    _tooltipContext(shape) {
         return {
             type: 'shape',
             layerIndex: this._layerIndex(),
@@ -241,50 +231,44 @@ export var ShapeLayer = (function (Layer) {
             dataItem: shape.dataItem,
             location: shape.location
         };
-    };
+    }
 
-    ShapeLayer.prototype._tooltipAnchor = function _tooltipAnchor (e) {
-        var cursor = this.map.eventOffset(e.originalEvent);
+    _tooltipAnchor(e) {
+        const cursor = this.map.eventOffset(e.originalEvent);
         return {
             top: cursor.y,
             left: cursor.x
         };
-    };
+    }
 
-    ShapeLayer.prototype._activate = function _activate () {
-        Layer.prototype._activate.call(this);
+    _activate() {
+        super._activate();
         this._panHandler = proxy(this._pan, this);
         this.map.bind('pan', this.panHandler);
-    };
+    }
 
-    ShapeLayer.prototype._deactivate = function _deactivate () {
-        Layer.prototype._deactivate.call(this);
+    _deactivate() {
+        super._deactivate();
         this.map.unbind('pan', this._panHandler);
-    };
-
-    return ShapeLayer;
-}(Layer));
+    }
+}
 
 setDefaultOptions(ShapeLayer, {
     autoBind: true,
     zIndex: 100
 });
 
-var GeoJsonLoader = (function (Class) {
-    function GeoJsonLoader(locator, defaultStyle, observer) {
-        Class.call(this);
+class GeoJsonLoader extends Class {
+    constructor(locator, defaultStyle, observer) {
+        super();
         this.observer = observer;
         this.locator = locator;
         this.style = defaultStyle;
     }
 
-    if ( Class ) GeoJsonLoader.__proto__ = Class;
-    GeoJsonLoader.prototype = Object.create( Class && Class.prototype );
-    GeoJsonLoader.prototype.constructor = GeoJsonLoader;
-
-    GeoJsonLoader.prototype.parse = function parse (item) {
-        var root = new Group();
-        var unwrap = true;
+    parse(item) {
+        let root = new Group();
+        let unwrap = true;
 
         if (item.type === 'Feature') {
             unwrap = false;
@@ -299,19 +283,19 @@ var GeoJsonLoader = (function (Class) {
         }
 
         return root;
-    };
+    }
 
-    GeoJsonLoader.prototype._shapeCreated = function _shapeCreated (shape) {
-        var cancelled = false;
+    _shapeCreated(shape) {
+        let cancelled = false;
 
         if (this.observer && this.observer.shapeCreated) {
             cancelled = this.observer.shapeCreated(shape);
         }
 
         return cancelled;
-    };
+    }
 
-    GeoJsonLoader.prototype._featureCreated = function _featureCreated (group, dataItem) {
+    _featureCreated(group, dataItem) {
         if (this.observer && this.observer.featureCreated) {
             this.observer.featureCreated({
                 group: group,
@@ -319,14 +303,12 @@ var GeoJsonLoader = (function (Class) {
                 properties: dataItem.properties
             });
         }
-    };
-
-    GeoJsonLoader.prototype._loadGeometryTo = function _loadGeometryTo (container, geometry, dataItem) {
-        var this$1 = this;
+    }
 
-        var coords = geometry.coordinates;
-        var i;
-        var path;
+    _loadGeometryTo(container, geometry, dataItem) {
+        let coords = geometry.coordinates;
+        let i;
+        let path;
 
         switch (geometry.type) {
             case 'LineString':
@@ -335,8 +317,8 @@ var GeoJsonLoader = (function (Class) {
                 break;
             case 'MultiLineString':
                 for (i = 0; i < coords.length; i++) {
-                    path = this$1._loadPolygon(container, [coords[i]], dataItem);
-                    this$1._setLineFill(path);
+                    path = this._loadPolygon(container, [coords[i]], dataItem);
+                    this._setLineFill(path);
                 }
                 break;
             case 'Polygon':
@@ -344,7 +326,7 @@ var GeoJsonLoader = (function (Class) {
                 break;
             case 'MultiPolygon':
                 for (i = 0; i < coords.length; i++) {
-                    this$1._loadPolygon(container, coords[i], dataItem);
+                    this._loadPolygon(container, coords[i], dataItem);
                 }
                 break;
             case 'Point':
@@ -352,46 +334,44 @@ var GeoJsonLoader = (function (Class) {
                 break;
             case 'MultiPoint':
                 for (i = 0; i < coords.length; i++) {
-                    this$1._loadPoint(container, coords[i], dataItem);
+                    this._loadPoint(container, coords[i], dataItem);
                 }
                 break;
             default:
                 break;
         }
-    };
+    }
 
-    GeoJsonLoader.prototype._setLineFill = function _setLineFill (path) {
-        var segments = path.segments;
+    _setLineFill(path) {
+        let segments = path.segments;
 
         if (segments.length < 4 || !segments[0].anchor().equals(last(segments).anchor())) {
             path.options.fill = null;
         }
-    };
+    }
 
-    GeoJsonLoader.prototype._loadShape = function _loadShape (container, shape) {
+    _loadShape(container, shape) {
         if (!this._shapeCreated(shape)) {
             container.append(shape);
         }
 
         return shape;
-    };
+    }
 
-    GeoJsonLoader.prototype._loadPolygon = function _loadPolygon (container, rings, dataItem) {
-        var shape = this._buildPolygon(rings);
+    _loadPolygon(container, rings, dataItem) {
+        let shape = this._buildPolygon(rings);
         shape.dataItem = dataItem;
         shape.location = this.locator.viewToLocation(shape.bbox().center());
         return this._loadShape(container, shape);
-    };
-
-    GeoJsonLoader.prototype._buildPolygon = function _buildPolygon (rings) {
-        var this$1 = this;
+    }
 
-        var type = rings.length > 1 ? d.MultiPath : d.Path;
-        var path = new type(this.style);
+    _buildPolygon(rings) {
+        let type = rings.length > 1 ? d.MultiPath : d.Path;
+        let path = new type(this.style);
 
-        for (var i = 0; i < rings.length; i++) {
-            for (var j = 0; j < rings[i].length; j++) {
-                var point = this$1.locator.locationToView(Location.fromLngLat(rings[i][j]));
+        for (let i = 0; i < rings.length; i++) {
+            for (let j = 0; j < rings[i].length; j++) {
+                let point = this.locator.locationToView(Location.fromLngLat(rings[i][j]));
                 if (j === 0) {
                     path.moveTo(point.x, point.y);
                 } else {
@@ -401,19 +381,17 @@ var GeoJsonLoader = (function (Class) {
         }
 
         return path;
-    };
+    }
 
-    GeoJsonLoader.prototype._loadPoint = function _loadPoint (container, coords, dataItem) {
-        var location = Location.fromLngLat(coords);
-        var point = this.locator.locationToView(location);
-        var circle = new g.Circle(point, 10);
-        var shape = new d.Circle(circle, this.style);
+    _loadPoint(container, coords, dataItem) {
+        let location = Location.fromLngLat(coords);
+        let point = this.locator.locationToView(location);
+        let circle = new g.Circle(point, 10);
+        let shape = new d.Circle(circle, this.style);
 
         shape.dataItem = dataItem;
         shape.location = location;
 
         return this._loadShape(container, shape);
-    };
-
-    return GeoJsonLoader;
-}(Class));
+    }
+}