@progress/kendo-charts 1.21.0 → 1.23.0-dev.202201120958

package/dist/es/map/extent.js

@@ -0,0 +1,129 @@
+import {
+    Class,
+    valueOrDefault
+} from '../common';
+
+import { Location } from './location';
+
+var math = Math,
+    max = math.max,
+    min = math.min;
+
+export var Extent = (function (Class) {
+    function Extent(initialNw, initialSe) {
+        Class.call(this);
+        var nw = Location.create(initialNw);
+        var se = Location.create(initialSe);
+
+        if (nw.lng + 180 > se.lng + 180 && nw.lat + 90 < se.lat + 90) {
+            this.se = nw;
+            this.nw = se;
+        } else {
+            this.se = se;
+            this.nw = nw;
+        }
+    }
+
+    if ( Class ) Extent.__proto__ = Class;
+    Extent.prototype = Object.create( Class && Class.prototype );
+    Extent.prototype.constructor = Extent;
+
+    var staticAccessors = { World: { configurable: true } };
+
+    Extent.prototype.contains = function contains (loc) {
+        var nw = this.nw, se = this.se, lng = valueOrDefault(loc.lng, loc[1]), lat = valueOrDefault(loc.lat, loc[0]);
+
+        return loc &&
+            lng + 180 >= nw.lng + 180 && lng + 180 <= se.lng + 180 &&
+            lat + 90 >= se.lat + 90 && lat + 90 <= nw.lat + 90;
+    };
+
+    Extent.prototype.center = function center () {
+        var nw = this.nw;
+        var se = this.se;
+        var lng = nw.lng + (se.lng - nw.lng) / 2;
+        var lat = nw.lat + (se.lat - nw.lat) / 2;
+
+        return new Location(lat, lng);
+    };
+
+    Extent.prototype.containsAny = function containsAny (locs) {
+        var this$1 = this;
+
+        var result = false;
+
+        for (var i = 0; i < locs.length; i++) {
+            result = result || this$1.contains(locs[i]);
+        }
+
+        return result;
+    };
+
+    Extent.prototype.include = function include (loc) {
+        var nw = this.nw, se = this.se, lng = valueOrDefault(loc.lng, loc[1]), lat = valueOrDefault(loc.lat, loc[0]);
+
+        nw.lng = min(nw.lng, lng);
+        nw.lat = max(nw.lat, lat);
+        se.lng = max(se.lng, lng);
+        se.lat = min(se.lat, lat);
+    };
+
+    Extent.prototype.includeAll = function includeAll (locs) {
+        var this$1 = this;
+
+        for (var i = 0; i < locs.length; i++) {
+            this$1.include(locs[i]);
+        }
+    };
+
+    Extent.prototype.edges = function edges () {
+        var nw = this.nw, se = this.se;
+
+        return {
+            nw: this.nw,
+            ne: new Location(nw.lat, se.lng),
+            se: this.se,
+            sw: new Location(se.lat, nw.lng)
+        };
+    };
+
+    Extent.prototype.toArray = function toArray () {
+        var nw = this.nw, se = this.se;
+
+        return [
+            nw,
+            new Location(nw.lat, se.lng),
+            se,
+            new Location(se.lat, nw.lng)
+        ];
+    };
+
+    Extent.prototype.overlaps = function overlaps (extent) {
+        return this.containsAny(extent.toArray()) ||
+            extent.containsAny(this.toArray());
+    };
+
+    Extent.create = function create (a, b) {
+        if (a instanceof Extent) {
+            return a;
+        } else if (a && b) {
+            return new Extent(a, b);
+        } else if (a && a.length === 4 && !b) {
+            return new Extent([
+                a[0],
+                a[1]
+            ], [
+                a[2],
+                a[3]
+            ]);
+        }
+    };
+
+    staticAccessors.World.get = function () {
+        return new Extent([ 90, -180 ], [ -90, 180 ]);
+    };
+
+    Object.defineProperties( Extent, staticAccessors );
+
+    return Extent;
+}(Class));

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

@@ -0,0 +1,185 @@
+import {
+    geometry as g,
+    drawing as d
+} from '@progress/kendo-drawing';
+
+import {
+    Class,
+    defined,
+    isFunction,
+    getter,
+    setDefaultOptions
+} from '../../common';
+
+import {
+    ShapeLayer
+} from './shape';
+
+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 || [];
+        return data;
+    };
+
+    BubbleLayer.prototype._load = function _load (data) {
+        var this$1 = this;
+
+        this._data = data;
+        this.surface.clear();
+
+        if (data.length === 0) {
+            return;
+        }
+
+        var options = this.options;
+        var getValue = getter(options.valueField);
+
+        var 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);
+
+        for (var i = 0; i < newData.length; i++) {
+            var dataItem = newData[i];
+            var location = getLocation(dataItem);
+            var value = getValue(dataItem);
+
+            if (defined(location) && defined(value)) {
+                if (!scale) {
+                    scale = new scaleType([
+                        0,
+                        value
+                    ], [
+                        options.minSize,
+                        options.maxSize
+                    ]);
+                }
+
+                location = Location.create(location);
+
+                var center = this$1.map.locationToView(location);
+                var size = scale.map(value);
+                var symbol = this$1._createSymbol({
+                    center: center,
+                    size: size,
+                    style: options.style,
+                    dataItem: dataItem,
+                    location: location
+                });
+
+                symbol.dataItem = dataItem;
+                symbol.location = location;
+                symbol.value = value;
+
+                this$1._drawSymbol(symbol);
+            }
+        }
+    };
+
+    BubbleLayer.prototype._scaleType = function _scaleType () {
+        var scale = this.options.scale;
+
+        if (isFunction(scale)) {
+            return scale;
+        }
+
+        return Scales[scale];
+    };
+
+    BubbleLayer.prototype._createSymbol = function _createSymbol (args) {
+        var symbol = this.options.symbol;
+
+        if (!isFunction(symbol)) {
+            symbol = Symbols[symbol];
+        }
+
+        return symbol(args);
+    };
+
+    BubbleLayer.prototype._drawSymbol = function _drawSymbol (shape) {
+        var args = {
+            layer: this,
+            shape: shape
+        };
+
+        var cancelled = this.map.trigger('shapeCreated', args);
+
+        if (!cancelled) {
+            this.surface.draw(shape);
+        }
+    };
+
+    return BubbleLayer;
+}(ShapeLayer));
+
+setDefaultOptions(BubbleLayer, {
+    // autoBind: true,
+    locationField: 'location',
+    valueField: 'value',
+    minSize: 0,
+    maxSize: 100,
+    scale: 'sqrt',
+    symbol: 'circle',
+    // ensure bubble layers are displayed over tile and shape layers
+    zIndex: 200
+});
+
+var SqrtScale = (function (Class) {
+    function SqrtScale(domain, range) {
+        Class.call(this);
+
+        this._domain = domain;
+        this._range = range;
+
+        var domainRange = Math.sqrt(domain[1]) - Math.sqrt(domain[0]);
+        var 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;
+        return this._range[0] + rel;
+    };
+
+    return SqrtScale;
+}(Class));
+
+var Scales = {
+    sqrt: SqrtScale
+};
+
+var Symbols = {
+    circle: function(args) {
+        var 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;
+        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

@@ -0,0 +1,140 @@
+import {
+    Class,
+    addClass,
+    deepExtend,
+    defined
+} from '../../common';
+
+import {
+    Extent
+} from './../extent';
+
+import {
+    getSupportedFeatures
+} from '../utils';
+
+export var Layer = (function (Class) {
+    function Layer(map, options) {
+        Class.call(this);
+
+        this.support = getSupportedFeatures();
+
+        this._initOptions(options);
+        this.map = map;
+
+        var element = document.createElement("div");
+        addClass(element, "k-layer");
+        element.style.zIndex = this.options.zIndex;
+        element.style.opacity = this.options.opacity;
+
+        this.element = element;
+
+        map.scrollElement.appendChild(this.element);
+
+        this._beforeReset = this._beforeReset.bind(this);
+        this._reset = this._reset.bind(this);
+        this._resize = this._resize.bind(this);
+        this._panEnd = this._panEnd.bind(this);
+
+        this._activate();
+        this._updateAttribution();
+    }
+
+    if ( Class ) Layer.__proto__ = Class;
+    Layer.prototype = Object.create( Class && Class.prototype );
+    Layer.prototype.constructor = Layer;
+
+    Layer.prototype.destroy = function destroy () {
+        this._deactivate();
+    };
+
+    Layer.prototype._initOptions = function _initOptions (options) {
+        this.options = deepExtend({}, this.options, options);
+    };
+
+    Layer.prototype.show = function show () {
+        this.reset();
+        this._activate();
+        this._applyExtent(true);
+    };
+
+    Layer.prototype.hide = function hide () {
+        this._deactivate();
+        this._setVisibility(false);
+    };
+
+    Layer.prototype.reset = function reset () {
+        this._beforeReset();
+        this._reset();
+    };
+
+    Layer.prototype._reset = function _reset () {
+        this._applyExtent();
+    };
+
+    Layer.prototype._beforeReset = function _beforeReset () {
+
+    };
+
+    Layer.prototype._resize = function _resize () {
+
+    };
+
+    Layer.prototype._panEnd = function _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());
+
+        this._setVisibility(matchMinZoom && matchMaxZoom && inside);
+    };
+
+    Layer.prototype._setVisibility = function _setVisibility (visible) {
+        this.element.style.display = visible ? '' : 'none';
+    };
+
+    Layer.prototype._activate = function _activate () {
+        var map = this.map;
+
+        this._deactivate();
+
+        map.bind('beforeReset', this._beforeReset);
+        map.bind('reset', this._reset);
+        map.bind('resize', this._resize);
+        map.bind('panEnd', this._panEnd);
+    };
+
+    Layer.prototype._deactivate = function _deactivate () {
+        var 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;
+
+        if (attribution) {
+            attribution.add(this.options.attribution);
+        }
+    };
+
+    Layer.prototype._readData = function _readData () {
+        var data = this.options.data || [];
+        return data;
+    };
+
+    Layer.prototype._hasData = function _hasData () {
+        return this._data && this._data.length > 0;
+    };
+
+    return Layer;
+}(Class));