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

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

@@ -19,7 +19,7 @@ import { Layer } from './layer';
 
 import TemplateService from '../../services/template-service';
 
-var math = Math,
+let math = Math,
     Point = g.Point;
 
 function compileTemplate(template) {
@@ -35,7 +35,7 @@ function roundPoint(point) {
 }
 
 function renderSize(size) {
-    var newSize = size;
+    let newSize = size;
 
     if (typeof(size) !== "string") {
         newSize += "px";
@@ -44,46 +44,42 @@ function renderSize(size) {
     return newSize;
 }
 
-export var TileLayer = (function (Layer) {
-    function TileLayer(map, options) {
-        Layer.call(this, map, options);
+export class TileLayer extends Layer {
+    constructor(map, options) {
+        super(map, options);
 
         if (typeof this.options.subdomains === 'string') {
             this.options.subdomains = this.options.subdomains.split('');
         }
 
-        var viewType = this._viewType();
+        let viewType = this._viewType();
         this._view = new viewType(this.element, this.options);
     }
 
-    if ( Layer ) TileLayer.__proto__ = Layer;
-    TileLayer.prototype = Object.create( Layer && Layer.prototype );
-    TileLayer.prototype.constructor = TileLayer;
-
-    TileLayer.prototype.destroy = function destroy () {
-        Layer.prototype.destroy.call(this);
+    destroy() {
+        super.destroy();
         this._view.destroy();
         this._view = null;
-    };
+    }
 
-    TileLayer.prototype._beforeReset = function _beforeReset () {
-        var map = this.map;
-        var origin = map.locationToLayer(map.extent().nw).round();
+    _beforeReset() {
+        let map = this.map;
+        let origin = map.locationToLayer(map.extent().nw).round();
         this._view.viewOrigin(origin);
-    };
+    }
 
-    TileLayer.prototype._reset = function _reset () {
-        Layer.prototype._reset.call(this);
+    _reset() {
+        super._reset();
         this._updateView();
         this._view.reset();
-    };
+    }
 
-    TileLayer.prototype._viewType = function _viewType () {
+    _viewType() {
         return TileView;
-    };
+    }
 
-    TileLayer.prototype._activate = function _activate () {
-        Layer.prototype._activate.call(this);
+    _activate() {
+        super._activate();
 
         if (!this.support.mobileOS) {
             if (!this._pan) {
@@ -92,18 +88,18 @@ export var TileLayer = (function (Layer) {
 
             this.map.bind('pan', this._pan);
         }
-    };
+    }
 
-    TileLayer.prototype._deactivate = function _deactivate () {
-        Layer.prototype._deactivate.call(this);
+    _deactivate() {
+        super._deactivate();
 
         if (this._pan) {
             this.map.unbind('pan', this._pan);
         }
-    };
+    }
 
-    TileLayer.prototype._updateView = function _updateView () {
-        var view = this._view,
+    _updateView() {
+        let view = this._view,
             map = this.map,
             extent = map.extent(),
             extentToPoint = {
@@ -114,24 +110,22 @@ export var TileLayer = (function (Layer) {
         view.center(map.locationToLayer(map.center()));
         view.extent(extentToPoint);
         view.zoom(map.zoom());
-    };
+    }
 
-    TileLayer.prototype._resize = function _resize () {
+    _resize() {
         this._render();
-    };
+    }
 
-    TileLayer.prototype._panEnd = function _panEnd (e) {
-        Layer.prototype._panEnd.call(this, e);
+    _panEnd(e) {
+        super._panEnd(e);
         this._render();
-    };
+    }
 
-    TileLayer.prototype._render = function _render () {
+    _render() {
         this._updateView();
         this._view.render();
-    };
-
-    return TileLayer;
-}(Layer));
+    }
+}
 
 setDefaultOptions(TileLayer, {
     tileSize: 256,
@@ -140,44 +134,40 @@ setDefaultOptions(TileLayer, {
     zIndex: 1
 });
 
-export var TileView = (function (Class) {
-    function TileView(element, options) {
-        Class.call(this);
+export class TileView extends Class {
+    constructor(element, options) {
+        super();
         this.element = element;
         this._initOptions(options);
         this.pool = new TilePool();
     }
 
-    if ( Class ) TileView.__proto__ = Class;
-    TileView.prototype = Object.create( Class && Class.prototype );
-    TileView.prototype.constructor = TileView;
-
-    TileView.prototype._initOptions = function _initOptions (options) {
+    _initOptions(options) {
         this.options = deepExtend({}, this.options, options);
-    };
+    }
 
-    TileView.prototype.center = function center (center$1) {
-        this._center = center$1;
-    };
+    center(center) {
+        this._center = center;
+    }
 
-    TileView.prototype.extent = function extent (extent$1) {
-        this._extent = extent$1;
-    };
+    extent(extent) {
+        this._extent = extent;
+    }
 
-    TileView.prototype.viewOrigin = function viewOrigin (origin) {
+    viewOrigin(origin) {
         this._viewOrigin = origin;
-    };
+    }
 
-    TileView.prototype.zoom = function zoom (zoom$1) {
-        this._zoom = zoom$1;
-    };
+    zoom(zoom) {
+        this._zoom = zoom;
+    }
 
-    TileView.prototype.pointToTileIndex = function pointToTileIndex (point) {
+    pointToTileIndex(point) {
         return new Point(math.floor(point.x / this.options.tileSize), math.floor(point.y / this.options.tileSize));
-    };
+    }
 
-    TileView.prototype.tileCount = function tileCount () {
-        var size = this.size(),
+    tileCount() {
+        let size = this.size(),
             firstTileIndex = this.pointToTileIndex(this._extent.nw),
             nw = this._extent.nw,
             point = this.indexToPoint(firstTileIndex).translate(-nw.x, -nw.y);
@@ -186,10 +176,10 @@ export var TileView = (function (Class) {
             x: math.ceil((math.abs(point.x) + size.width) / this.options.tileSize),
             y: math.ceil((math.abs(point.y) + size.height) / this.options.tileSize)
         };
-    };
+    }
 
-    TileView.prototype.size = function size () {
-        var nw = this._extent.nw,
+    size() {
+        let nw = this._extent.nw,
             se = this._extent.se,
             diff = se.clone().translate(-nw.x, -nw.y);
 
@@ -197,41 +187,39 @@ export var TileView = (function (Class) {
             width: diff.x,
             height: diff.y
         };
-    };
+    }
 
-    TileView.prototype.indexToPoint = function indexToPoint (index) {
-        var x = index.x,
+    indexToPoint(index) {
+        let x = index.x,
             y = index.y;
 
         return new Point(x * this.options.tileSize, y * this.options.tileSize);
-    };
+    }
 
-    TileView.prototype.subdomainText = function subdomainText () {
-        var subdomains = this.options.subdomains;
+    subdomainText() {
+        let subdomains = this.options.subdomains;
         return subdomains[this.subdomainIndex++ % subdomains.length];
-    };
+    }
 
-    TileView.prototype.destroy = function destroy () {
+    destroy() {
         removeChildren(this.element);
         this.pool.empty();
-    };
+    }
 
-    TileView.prototype.reset = function reset () {
+    reset() {
         this.pool.reset();
         this.subdomainIndex = 0;
         this.render();
-    };
-
-    TileView.prototype.render = function render () {
-        var this$1 = this;
+    }
 
-        var size = this.tileCount(),
+    render() {
+        let size = this.tileCount(),
             firstTileIndex = this.pointToTileIndex(this._extent.nw),
             tile, x, y;
 
         for (x = 0; x < size.x; x++) {
             for (y = 0; y < size.y; y++) {
-                tile = this$1.createTile({
+                tile = this.createTile({
                     x: firstTileIndex.x + x,
                     y: firstTileIndex.y + y
                 });
@@ -241,21 +229,21 @@ export var TileView = (function (Class) {
                 }
             }
         }
-    };
+    }
 
-    TileView.prototype.createTile = function createTile (currentIndex) {
-        var options = this.tileOptions(currentIndex);
-        var tile = this.pool.get(this._center, options);
+    createTile(currentIndex) {
+        let options = this.tileOptions(currentIndex);
+        let tile = this.pool.get(this._center, options);
 
         if (!tile.element.parentNode) {
             this.element.append(tile.element);
         }
 
         return tile;
-    };
+    }
 
-    TileView.prototype.tileOptions = function tileOptions (currentIndex) {
-        var index = this.wrapIndex(currentIndex),
+    tileOptions(currentIndex) {
+        let index = this.wrapIndex(currentIndex),
             point = this.indexToPoint(currentIndex),
             origin = this._viewOrigin,
             offset = point.clone().translate(-origin.x, -origin.y);
@@ -271,20 +259,20 @@ export var TileView = (function (Class) {
             urlTemplate: this.options.urlTemplate,
             errorUrlTemplate: this.options.errorUrlTemplate
         };
-    };
+    }
 
-    TileView.prototype.wrapIndex = function wrapIndex (index) {
-        var boundary = math.pow(2, this._zoom);
+    wrapIndex(index) {
+        let boundary = math.pow(2, this._zoom);
 
         return {
             x: this.wrapValue(index.x, boundary),
             y: limitValue(index.y, 0, boundary - 1)
         };
-    };
+    }
 
-    TileView.prototype.wrapValue = function wrapValue (value, boundary) {
-        var remainder = math.abs(value) % boundary;
-        var wrappedValue = value;
+    wrapValue(value, boundary) {
+        let remainder = math.abs(value) % boundary;
+        let wrappedValue = value;
 
         if (value >= 0) {
             wrappedValue = remainder;
@@ -293,14 +281,12 @@ export var TileView = (function (Class) {
         }
 
         return wrappedValue;
-    };
-
-    return TileView;
-}(Class));
+    }
+}
 
-export var ImageTile = (function (Class) {
-    function ImageTile(id, options) {
-        Class.call(this);
+export class ImageTile extends Class {
+    constructor(id, options) {
+        super();
         this.id = id;
         this.visible = true;
         this._initOptions(options);
@@ -308,13 +294,9 @@ export var ImageTile = (function (Class) {
         this.show();
     }
 
-    if ( Class ) ImageTile.__proto__ = Class;
-    ImageTile.prototype = Object.create( Class && Class.prototype );
-    ImageTile.prototype.constructor = ImageTile;
-
-    ImageTile.prototype.destroy = function destroy () {
-        var element = this.element;
-        var parentNode = element ? element.parentNode : null;
+    destroy() {
+        const element = this.element;
+        const parentNode = element ? element.parentNode : null;
 
         if (element) {
             if (parentNode) {
@@ -323,15 +305,15 @@ export var ImageTile = (function (Class) {
 
             this.element = null;
         }
-    };
+    }
 
-    ImageTile.prototype._initOptions = function _initOptions (options) {
+    _initOptions(options) {
         this.options = deepExtend({}, this.options, options);
-    };
+    }
 
-    ImageTile.prototype.createElement = function createElement () {
-        var el = document.createElement("img");
-        var size = this.options.size + "px";
+    createElement() {
+        let el = document.createElement("img");
+        const size = this.options.size + "px";
         el.setAttribute("alt", "");
         el.style.position = "absolute";
         el.style.display = "block";
@@ -356,14 +338,14 @@ export var ImageTile = (function (Class) {
         //         e.target.removeAttribute('src');
         //     }
         // }, this));
-    };
+    }
 
-    ImageTile.prototype.show = function show () {
-        var element = this.element;
+    show() {
+        let element = this.element;
         element.style.top = renderSize(this.options.offset.y);
         element.style.left = renderSize(this.options.offset.x);
 
-        var url = this.url();
+        let url = this.url();
 
         if (url) {
             element.setAttribute('src', url);
@@ -371,25 +353,25 @@ export var ImageTile = (function (Class) {
 
         element.style.visibility = 'visible';
         this.visible = true;
-    };
+    }
 
-    ImageTile.prototype.hide = function hide () {
+    hide() {
         this.element.style.visibility = 'hidden';
         this.visible = false;
-    };
+    }
 
-    ImageTile.prototype.url = function url () {
-        var urlResult = compileTemplate(this.options.urlTemplate);
+    url() {
+        let urlResult = compileTemplate(this.options.urlTemplate);
         return urlResult(this.urlOptions());
-    };
+    }
 
-    ImageTile.prototype.errorUrl = function errorUrl () {
-        var urlResult = compileTemplate(this.options.errorUrlTemplate);
+    errorUrl() {
+        let urlResult = compileTemplate(this.options.errorUrlTemplate);
         return urlResult(this.urlOptions());
-    };
+    }
 
-    ImageTile.prototype.urlOptions = function urlOptions () {
-        var options = this.options;
+    urlOptions() {
+        let options = this.options;
 
         return {
             zoom: options.zoom,
@@ -403,58 +385,52 @@ export var ImageTile = (function (Class) {
             culture: options.culture,
             c: options.culture
         };
-    };
-
-    return ImageTile;
-}(Class));
+    }
+}
 
 setDefaultOptions(ImageTile, {
     urlTemplate: '',
     errorUrlTemplate: ''
 });
 
-export var TilePool = (function (Class) {
-    function TilePool() {
-        Class.call(this);
+export class TilePool extends Class {
+    constructor() {
+        super();
         this._items = [];
     }
 
-    if ( Class ) TilePool.__proto__ = Class;
-    TilePool.prototype = Object.create( Class && Class.prototype );
-    TilePool.prototype.constructor = TilePool;
-
-    TilePool.prototype.get = function get (center, options) {
+    get(center, options) {
         if (this._items.length >= this.options.maxSize) {
             this._remove(center);
         }
 
         return this._create(options);
-    };
+    }
 
-    TilePool.prototype.empty = function empty () {
-        var items = this._items;
+    empty() {
+        let items = this._items;
 
-        for (var i = 0; i < items.length; i++) {
+        for (let i = 0; i < items.length; i++) {
             items[i].destroy();
         }
 
         this._items = [];
-    };
+    }
 
-    TilePool.prototype.reset = function reset () {
-        var items = this._items;
+    reset() {
+        let items = this._items;
 
-        for (var i = 0; i < items.length; i++) {
+        for (let i = 0; i < items.length; i++) {
             items[i].hide();
         }
-    };
+    }
 
-    TilePool.prototype._create = function _create (options) {
-        var items = this._items;
-        var tile;
-        var id = hashKey(options.point.toString() + options.offset.toString() + options.zoom + options.urlTemplate);
+    _create(options) {
+        let items = this._items;
+        let tile;
+        let id = hashKey(options.point.toString() + options.offset.toString() + options.zoom + options.urlTemplate);
 
-        for (var i = 0; i < items.length; i++) {
+        for (let i = 0; i < items.length; i++) {
             if (items[i].id === id) {
                 tile = items[i];
                 break;
@@ -469,15 +445,15 @@ export var TilePool = (function (Class) {
         }
 
         return tile;
-    };
+    }
 
-    TilePool.prototype._remove = function _remove (center) {
-        var items = this._items;
-        var maxDist = -1;
-        var index = -1;
+    _remove(center) {
+        let items = this._items;
+        let maxDist = -1;
+        let index = -1;
 
-        for (var i = 0; i < items.length; i++) {
-            var dist = items[i].options.point.distanceTo(center);
+        for (let i = 0; i < items.length; i++) {
+            let dist = items[i].options.point.distanceTo(center);
 
             if (dist > maxDist && !items[i].visible) {
                 index = i;
@@ -489,10 +465,8 @@ export var TilePool = (function (Class) {
             items[index].destroy();
             items.splice(index, 1);
         }
-    };
-
-    return TilePool;
-}(Class));
+    }
+}
 
 setDefaultOptions(TilePool, {
     maxSize: 100