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

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

@@ -19,23 +19,13 @@ import {
     Location
 } from '../location';
 
-export var BubbleLayer = (function (ShapeLayer) {
-    function BubbleLayer () {
-        ShapeLayer.apply(this, arguments);
-    }
-
-    if ( ShapeLayer ) BubbleLayer.__proto__ = ShapeLayer;
-    BubbleLayer.prototype = Object.create( ShapeLayer && ShapeLayer.prototype );
-    BubbleLayer.prototype.constructor = BubbleLayer;
-
-    BubbleLayer.prototype._readData = function _readData () {
-        var data = this.options.data || [];
+export class BubbleLayer extends ShapeLayer {
+    _readData() {
+        const data = this.options.data || [];
         return data;
-    };
-
-    BubbleLayer.prototype._load = function _load (data) {
-        var this$1 = this;
+    }
 
+    _load(data) {
         this._data = data;
         this.surface.clear();
 
@@ -43,22 +33,22 @@ export var BubbleLayer = (function (ShapeLayer) {
             return;
         }
 
-        var options = this.options;
-        var getValue = getter(options.valueField);
+        let options = this.options;
+        let getValue = getter(options.valueField);
 
-        var newData = data.slice(0);
+        let newData = data.slice(0);
         newData.sort(function(a, b) {
             return getValue(b) - getValue(a);
         });
 
-        var scaleType = this._scaleType();
-        var scale;
-        var getLocation = getter(this.options.locationField);
+        let scaleType = this._scaleType();
+        let scale;
+        let getLocation = getter(this.options.locationField);
 
-        for (var i = 0; i < newData.length; i++) {
-            var dataItem = newData[i];
-            var location = getLocation(dataItem);
-            var value = getValue(dataItem);
+        for (let i = 0; i < newData.length; i++) {
+            let dataItem = newData[i];
+            let location = getLocation(dataItem);
+            let value = getValue(dataItem);
 
             if (defined(location) && defined(value)) {
                 if (!scale) {
@@ -73,9 +63,9 @@ export var BubbleLayer = (function (ShapeLayer) {
 
                 location = Location.create(location);
 
-                var center = this$1.map.locationToView(location);
-                var size = scale.map(value);
-                var symbol = this$1._createSymbol({
+                let center = this.map.locationToView(location);
+                let size = scale.map(value);
+                let symbol = this._createSymbol({
                     center: center,
                     size: size,
                     style: options.style,
@@ -87,45 +77,45 @@ export var BubbleLayer = (function (ShapeLayer) {
                 symbol.location = location;
                 symbol.value = value;
 
-                this$1._drawSymbol(symbol);
+                this._drawSymbol(symbol);
             }
         }
-    };
+    }
 
-    BubbleLayer.prototype._scaleType = function _scaleType () {
-        var scale = this.options.scale;
+    _scaleType() {
+        let scale = this.options.scale;
 
         if (isFunction(scale)) {
             return scale;
         }
 
         return Scales[scale];
-    };
+    }
 
-    BubbleLayer.prototype._createSymbol = function _createSymbol (args) {
-        var symbol = this.options.symbol;
+    _createSymbol(args) {
+        let symbol = this.options.symbol;
 
         if (!isFunction(symbol)) {
             symbol = Symbols[symbol];
         }
 
         return symbol(args);
-    };
+    }
 
-    BubbleLayer.prototype._drawSymbol = function _drawSymbol (shape) {
-        var args = {
+    _drawSymbol(shape) {
+        let args = {
             layer: this,
             shape: shape
         };
 
-        var cancelled = this.map.trigger('shapeCreated', args);
+        let cancelled = this.map.trigger('shapeCreated', args);
 
         if (!cancelled) {
             this.surface.draw(shape);
         }
-    };
+    }
 
-    BubbleLayer.prototype._tooltipContext = function _tooltipContext (shape) {
+    _tooltipContext(shape) {
         return {
             type: 'bubble',
             layerIndex: this._layerIndex(),
@@ -134,20 +124,18 @@ export var BubbleLayer = (function (ShapeLayer) {
             location: shape.location,
             value: shape.value
         };
-    };
+    }
 
-    BubbleLayer.prototype._tooltipAnchor = function _tooltipAnchor (e) {
-        var shape = e.element;
-        var center = shape.bbox().center();
+    _tooltipAnchor(e) {
+        const shape = e.element;
+        const center = shape.bbox().center();
 
         return {
             top: center.y,
             left: center.x
         };
-    };
-
-    return BubbleLayer;
-}(ShapeLayer));
+    }
+}
 
 setDefaultOptions(BubbleLayer, {
     // autoBind: true,
@@ -161,45 +149,39 @@ setDefaultOptions(BubbleLayer, {
     zIndex: 200
 });
 
-var SqrtScale = (function (Class) {
-    function SqrtScale(domain, range) {
-        Class.call(this);
+class SqrtScale extends Class {
+    constructor(domain, range) {
+        super();
 
         this._domain = domain;
         this._range = range;
 
-        var domainRange = Math.sqrt(domain[1]) - Math.sqrt(domain[0]);
-        var outputRange = range[1] - range[0];
+        let domainRange = Math.sqrt(domain[1]) - Math.sqrt(domain[0]);
+        let outputRange = range[1] - range[0];
 
         this._ratio = outputRange / domainRange;
     }
 
-    if ( Class ) SqrtScale.__proto__ = Class;
-    SqrtScale.prototype = Object.create( Class && Class.prototype );
-    SqrtScale.prototype.constructor = SqrtScale;
-
-    SqrtScale.prototype.map = function map (value) {
-        var rel = (Math.sqrt(value) - Math.sqrt(this._domain[0])) * this._ratio;
+    map(value) {
+        let rel = (Math.sqrt(value) - Math.sqrt(this._domain[0])) * this._ratio;
         return this._range[0] + rel;
-    };
-
-    return SqrtScale;
-}(Class));
+    }
+}
 
-var Scales = {
+let Scales = {
     sqrt: SqrtScale
 };
 
-var Symbols = {
+let Symbols = {
     circle: function(args) {
-        var geo = new g.Circle(args.center, args.size / 2);
+        let geo = new g.Circle(args.center, args.size / 2);
         return new d.Circle(geo, args.style);
     },
 
     square: function(args) {
-        var path = new d.Path(args.style);
-        var halfSize = args.size / 2;
-        var center = args.center;
+        let path = new d.Path(args.style);
+        let halfSize = args.size / 2;
+        let center = args.center;
         path.moveTo(center.x - halfSize, center.y - halfSize).lineTo(center.x + halfSize, center.y - halfSize).lineTo(center.x + halfSize, center.y + halfSize).lineTo(center.x - halfSize, center.y + halfSize).close();
         return path;
     }

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

@@ -10,16 +10,16 @@ import {
     Extent
 } from './../extent';
 
-export var Layer = (function (Class) {
-    function Layer(map, options) {
-        Class.call(this);
+export class Layer extends Class {
+    constructor(map, options) {
+        super();
 
         this.support = getSupportedFeatures();
 
         this._initOptions(options);
         this.map = map;
 
-        var element = document.createElement("div");
+        let element = document.createElement("div");
         addClass(element, "k-layer");
         element.style.zIndex = this.options.zIndex;
         element.style.opacity = this.options.opacity;
@@ -37,67 +37,63 @@ export var Layer = (function (Class) {
         this._updateAttribution();
     }
 
-    if ( Class ) Layer.__proto__ = Class;
-    Layer.prototype = Object.create( Class && Class.prototype );
-    Layer.prototype.constructor = Layer;
-
-    Layer.prototype.destroy = function destroy () {
+    destroy() {
         this._deactivate();
-    };
+    }
 
-    Layer.prototype._initOptions = function _initOptions (options) {
+    _initOptions(options) {
         this.options = deepExtend({}, this.options, options);
-    };
+    }
 
-    Layer.prototype.show = function show () {
+    show() {
         this.reset();
         this._activate();
         this._applyExtent(true);
-    };
+    }
 
-    Layer.prototype.hide = function hide () {
+    hide() {
         this._deactivate();
         this._setVisibility(false);
-    };
+    }
 
-    Layer.prototype.reset = function reset () {
+    reset() {
         this._beforeReset();
         this._reset();
-    };
+    }
 
-    Layer.prototype._reset = function _reset () {
+    _reset() {
         this._applyExtent();
-    };
+    }
 
-    Layer.prototype._beforeReset = function _beforeReset () {
+    _beforeReset() {
 
-    };
+    }
 
-    Layer.prototype._resize = function _resize () {
+    _resize() {
 
-    };
+    }
 
-    Layer.prototype._panEnd = function _panEnd () {
+    _panEnd() {
         this._applyExtent();
-    };
+    }
 
-    Layer.prototype._applyExtent = function _applyExtent () {
-        var options = this.options;
-        var zoom = this.map.zoom();
-        var matchMinZoom = !defined(options.minZoom) || zoom >= options.minZoom;
-        var matchMaxZoom = !defined(options.maxZoom) || zoom <= options.maxZoom;
-        var extent = Extent.create(options.extent);
-        var inside = !extent || extent.overlaps(this.map.extent());
+    _applyExtent() {
+        let options = this.options;
+        let zoom = this.map.zoom();
+        let matchMinZoom = !defined(options.minZoom) || zoom >= options.minZoom;
+        let matchMaxZoom = !defined(options.maxZoom) || zoom <= options.maxZoom;
+        let extent = Extent.create(options.extent);
+        let inside = !extent || extent.overlaps(this.map.extent());
 
         this._setVisibility(matchMinZoom && matchMaxZoom && inside);
-    };
+    }
 
-    Layer.prototype._setVisibility = function _setVisibility (visible) {
+    _setVisibility(visible) {
         this.element.style.display = visible ? '' : 'none';
-    };
+    }
 
-    Layer.prototype._activate = function _activate () {
-        var map = this.map;
+    _activate() {
+        let map = this.map;
 
         this._deactivate();
 
@@ -105,38 +101,36 @@ export var Layer = (function (Class) {
         map.bind('reset', this._reset);
         map.bind('resize', this._resize);
         map.bind('panEnd', this._panEnd);
-    };
+    }
 
-    Layer.prototype._deactivate = function _deactivate () {
-        var map = this.map;
+    _deactivate() {
+        let map = this.map;
 
         map.unbind('beforeReset', this._beforeReset);
         map.unbind('reset', this._reset);
         map.unbind('resize', this._resize);
         map.unbind('panEnd', this._panEnd);
-    };
+    }
 
-    Layer.prototype._updateAttribution = function _updateAttribution () {
-        var attribution = this.map.attribution;
+    _updateAttribution() {
+        const attribution = this.map.attribution;
 
         if (attribution) {
             attribution.add(this.options.attribution);
         }
-    };
+    }
 
-    Layer.prototype._readData = function _readData () {
-        var data = this.options.data || [];
+    _readData() {
+        const data = this.options.data || [];
         return data;
-    };
+    }
 
-    Layer.prototype._hasData = function _hasData () {
+    _hasData() {
         return this._data && this._data.length > 0;
-    };
+    }
 
-    Layer.prototype._layerIndex = function _layerIndex () {
-        var layers = this.map.layers || [];
+    _layerIndex() {
+        const layers = this.map.layers || [];
         return layers.indexOf(this);
-    };
-
-    return Layer;
-}(Class));
+    }
+}