@progress/kendo-charts 1.22.0 → 1.23.0-dev.202201170838

package/dist/es/common/keys.js

@@ -0,0 +1,25 @@
+var keys = {
+    INSERT: 45,
+    DELETE: 46,
+    BACKSPACE: 8,
+    TAB: 9,
+    ENTER: 13,
+    ESC: 27,
+    LEFT: 37,
+    UP: 38,
+    RIGHT: 39,
+    DOWN: 40,
+    END: 35,
+    HOME: 36,
+    SPACEBAR: 32,
+    PAGEUP: 33,
+    PAGEDOWN: 34,
+    F2: 113,
+    F10: 121,
+    F12: 123,
+    NUMPAD_PLUS: 107,
+    NUMPAD_MINUS: 109,
+    NUMPAD_DOT: 110
+};
+
+export default keys;

package/dist/es/common.js

@@ -30,5 +30,6 @@ export { default as elementScale } from './common/element-scale';
 export { default as autoTextColor } from './common/auto-text-color';
 export { default as createHashSet } from './common/create-hash-set';
 export { default as defaultErrorHandler } from './common/default-error-handler';
+export { default as keys } from './common/keys';
 
 export * from './drawing-utils';

package/dist/es/drawing-utils.js

@@ -1,4 +1,8 @@
-import { drawing, Class, logToConsole } from '@progress/kendo-drawing';
+import {
+    drawing,
+    Class,
+    logToConsole
+} from '@progress/kendo-drawing';
 
 var ref = drawing.util;
 var append = ref.append;
@@ -7,8 +11,9 @@ var defined = ref.defined;
 var deg = ref.deg;
 var elementOffset = ref.elementOffset;
 var elementSize = ref.elementSize;
-var eventElement = ref.eventElement;
 var eventCoordinates = ref.eventCoordinates;
+var eventElement = ref.eventElement;
+var hashKey = ref.hashKey;
 var last = ref.last;
 var limitValue = ref.limitValue;
 var objectKey = ref.objectKey;
@@ -17,4 +22,23 @@ var round = ref.round;
 var unbindEvents = ref.unbindEvents;
 var valueOrDefault = ref.valueOrDefault;
 
-export { append, bindEvents, Class, defined, deg, elementOffset, elementSize, eventElement, eventCoordinates, last, limitValue, logToConsole, objectKey, rad, round, unbindEvents, valueOrDefault };
+export {
+    append,
+    bindEvents,
+    Class,
+    defined,
+    deg,
+    elementOffset,
+    elementSize,
+    eventCoordinates,
+    eventElement,
+    hashKey,
+    last,
+    limitValue,
+    logToConsole,
+    objectKey,
+    rad,
+    round,
+    unbindEvents,
+    valueOrDefault
+};

package/dist/es/main.js

@@ -6,6 +6,7 @@ export * from './stock';
 export * from './gauges';
 export * from './barcode';
 export * from './qrcode';
+export * from './map';
 export * from './common';
 
 export { baseTheme as chartBaseTheme } from './chart/base-theme';

package/dist/es/map/attribution.js

@@ -0,0 +1,158 @@
+import {
+    addClass,
+    defined,
+    valueOrDefault,
+    deepExtend,
+    setDefaultOptions
+} from '../common';
+
+import TemplateService from '../services/template-service';
+
+import {
+    appendHtml,
+    removeChildren
+} from './utils';
+
+import { Observable } from './scroller/observable';
+
+var template = TemplateService.compile;
+
+export var Attribution = (function (Observable) {
+    function Attribution(element, options) {
+        Observable.call(this);
+        this.element = element;
+
+        this._initOptions(options);
+        this.items = [];
+
+        addClass(this.element, 'k-widget k-attribution');
+    }
+
+    if ( Observable ) Attribution.__proto__ = Observable;
+    Attribution.prototype = Object.create( Observable && Observable.prototype );
+    Attribution.prototype.constructor = Attribution;
+
+    Attribution.prototype._initOptions = function _initOptions (options) {
+        this.options = deepExtend({}, this.options, options);
+    };
+
+    Attribution.prototype.filter = function filter (extent, zoom) {
+        this._extent = extent;
+        this._zoom = zoom;
+        this._render();
+    };
+
+    Attribution.prototype.add = function add (item) {
+        var newItem = item;
+
+        if (defined(item)) {
+            if (typeof item === 'string') {
+                newItem = {
+                    text: item
+                };
+            }
+
+            this.items.push(newItem);
+            this._render();
+        }
+    };
+
+    Attribution.prototype.remove = function remove (text) {
+        var this$1 = this;
+
+        var result = [];
+
+        for (var i = 0; i < this.items.length; i++) {
+            var item = this$1.items[i];
+
+            if (item.text !== text) {
+                result.push(item);
+            }
+        }
+
+        this.items = result;
+        this._render();
+    };
+
+    Attribution.prototype.clear = function clear () {
+        this.items = [];
+        removeChildren(this.element);
+    };
+
+    Attribution.prototype._render = function _render () {
+        var this$1 = this;
+
+        var result = [];
+        var itemTemplate = template(this.options.itemTemplate);
+
+        for (var i = 0; i < this.items.length; i++) {
+            var item = this$1.items[i];
+            var text = this$1._itemText(item);
+
+            if (text !== '') {
+                result.push(itemTemplate({
+                    text: text
+                }));
+            }
+        }
+
+        if (result.length > 0) {
+            removeChildren(this.element);
+
+            var html = result.join(this.options.separator);
+            appendHtml(html, this.element);
+
+            this.showElement();
+        } else {
+            this.hideElement();
+        }
+    };
+
+    Attribution.prototype.hideElement = function hideElement () {
+        this.element.style.display = "none";
+    };
+
+    Attribution.prototype.showElement = function showElement () {
+        this.element.style.display = "";
+    };
+
+    Attribution.prototype._itemText = function _itemText (item) {
+        var text = '';
+        var inZoomLevel = this._inZoomLevel(item.minZoom, item.maxZoom);
+        var inArea = this._inArea(item.extent);
+
+        if (inZoomLevel && inArea) {
+            text += item.text;
+        }
+
+        return text;
+    };
+
+    Attribution.prototype._inZoomLevel = function _inZoomLevel (min, max) {
+        var result = true;
+        var newMin = valueOrDefault(min, -Number.MAX_VALUE);
+        var newMax = valueOrDefault(max, Number.MAX_VALUE);
+
+        result = this._zoom > newMin && this._zoom < newMax;
+        return result;
+    };
+
+    Attribution.prototype._inArea = function _inArea (area) {
+        var result = true;
+
+        if (area) {
+            result = area.contains(this._extent);
+        }
+
+        return result;
+    };
+
+    return Attribution;
+}(Observable));
+
+setDefaultOptions(Attribution, {
+    name: 'Attribution',
+    separator: '&nbsp;|&nbsp;',
+    itemTemplate: '#= text #'
+});
+

package/dist/es/map/crs.js

@@ -0,0 +1,277 @@
+import {
+    geometry as g
+} from '@progress/kendo-drawing';
+
+import {
+    Class,
+    setDefaultOptions,
+    limitValue,
+    rad,
+    deg,
+    deepExtend
+} from '../common';
+
+import {
+    Location
+} from './location';
+
+import {
+    datums
+} from './datums';
+
+
+var math = Math,
+    atan = math.atan,
+    exp = math.exp,
+    pow = math.pow,
+    sin = math.sin,
+    log = math.log,
+    tan = math.tan,
+    Point = g.Point;
+
+var PI = math.PI,
+    PI_DIV_2 = PI / 2,
+    PI_DIV_4 = PI / 4,
+    DEG_TO_RAD = PI / 180;
+
+var WGS84 = datums.WGS84;
+
+// WGS 84 / World Mercator
+export var Mercator = (function (Class) {
+    function Mercator(options) {
+        Class.call(this);
+        this.initProperties();
+        this._initOptions(options);
+    }
+
+    if ( Class ) Mercator.__proto__ = Class;
+    Mercator.prototype = Object.create( Class && Class.prototype );
+    Mercator.prototype.constructor = Mercator;
+
+    Mercator.prototype._initOptions = function _initOptions (options) {
+        this.options = deepExtend({}, this.options, options);
+    };
+
+    Mercator.prototype.initProperties = function initProperties () {
+        // super.initProperties();
+
+        deepExtend(this, {
+            MAX_LNG: 180,
+            MAX_LAT: 85.0840590501,
+            INVERSE_ITERATIONS: 15,
+            INVERSE_CONVERGENCE: 1e-12
+        });
+    };
+
+    Mercator.prototype.forward = function forward (loc, clamp) {
+        var proj = this,
+            options = proj.options,
+            datum = options.datum,
+            r = datum.a,
+            lng0 = options.centralMeridian,
+            lat = limitValue(loc.lat, -proj.MAX_LAT, proj.MAX_LAT),
+            lng = clamp ? limitValue(loc.lng, -proj.MAX_LNG, proj.MAX_LNG) : loc.lng,
+            x = rad(lng - lng0) * r,
+            y = proj._projectLat(lat);
+        return new Point(x, y);
+    };
+    Mercator.prototype._projectLat = function _projectLat (lat) {
+        var datum = this.options.datum,
+            ecc = datum.e,
+            r = datum.a,
+            y = rad(lat),
+            ts = tan(PI_DIV_4 + y / 2),
+            con = ecc * sin(y),
+            p = pow((1 - con) / (1 + con), ecc / 2);
+
+        // See: http://en.wikipedia.org/wiki/Mercator_projection#Generalization_to_the_ellipsoid
+        return r * log(ts * p);
+    };
+    Mercator.prototype.inverse = function inverse (point, clamp) {
+        var proj = this,
+            options = proj.options,
+            datum = options.datum,
+            r = datum.a,
+            lng0 = options.centralMeridian,
+            lng = point.x / (DEG_TO_RAD * r) + lng0,
+            lat = limitValue(proj._inverseY(point.y), -proj.MAX_LAT, proj.MAX_LAT);
+        if (clamp) {
+            lng = limitValue(lng, -proj.MAX_LNG, proj.MAX_LNG);
+        }
+        return new Location(lat, lng);
+    };
+    Mercator.prototype._inverseY = function _inverseY (y) {
+        var proj = this,
+            datum = proj.options.datum,
+            r = datum.a,
+            ecc = datum.e,
+            ecch = ecc / 2,
+            ts = exp(-y / r),
+            phi = PI_DIV_2 - 2 * atan(ts),
+            i;
+        for (i = 0; i <= proj.INVERSE_ITERATIONS; i++) {
+            var con = ecc * sin(phi),
+                p = pow((1 - con) / (1 + con), ecch),
+                dphi = PI_DIV_2 - 2 * atan(ts * p) - phi;
+            phi += dphi;
+            if (math.abs(dphi) <= proj.INVERSE_CONVERGENCE) {
+                break;
+            }
+        }
+        return deg(phi);
+    };
+
+    return Mercator;
+}(Class));
+
+setDefaultOptions(Mercator, {
+    centralMeridian: 0,
+    datum: WGS84
+});
+
+
+// WGS 84 / Pseudo-Mercator
+// Used by Google Maps, Bing, OSM, etc.
+// Spherical projection of ellipsoidal coordinates.
+export var SphericalMercator = (function (Mercator) {
+    function SphericalMercator () {
+        Mercator.apply(this, arguments);
+    }
+
+    if ( Mercator ) SphericalMercator.__proto__ = Mercator;
+    SphericalMercator.prototype = Object.create( Mercator && Mercator.prototype );
+    SphericalMercator.prototype.constructor = SphericalMercator;
+
+    SphericalMercator.prototype.initProperties = function initProperties () {
+        Mercator.prototype.initProperties.call(this);
+
+        deepExtend(this, {
+            MAX_LAT: 85.0511287798
+        });
+    };
+
+    SphericalMercator.prototype._projectLat = function _projectLat (lat) {
+        var r = this.options.datum.a,
+            y = rad(lat),
+            ts = tan(PI_DIV_4 + y / 2);
+        return r * log(ts);
+    };
+
+    SphericalMercator.prototype._inverseY = function _inverseY (y) {
+        var r = this.options.datum.a,
+            ts = exp(-y / r);
+        return deg(PI_DIV_2 - 2 * atan(ts));
+    };
+
+    return SphericalMercator;
+}(Mercator));
+
+export var Equirectangular = (function (Class) {
+    function Equirectangular () {
+        Class.apply(this, arguments);
+    }
+
+    if ( Class ) Equirectangular.__proto__ = Class;
+    Equirectangular.prototype = Object.create( Class && Class.prototype );
+    Equirectangular.prototype.constructor = Equirectangular;
+
+    Equirectangular.prototype.forward = function forward (loc) {
+        return new Point(loc.lng, loc.lat);
+    };
+    Equirectangular.prototype.inverse = function inverse (point) {
+        return new Location(point.y, point.x);
+    };
+
+    return Equirectangular;
+}(Class));
+
+// This is the projected coordinate system used for rendering maps in Google Maps, OpenStreetMap, etc
+// Unit: metre
+// Geodetic CRS: WGS 84
+// Scope: Certain Web mapping and visualisation applications. It is not a recognised geodetic system: for that see ellipsoidal Mercator CRS code 3395 (WGS 84 / World Mercator).
+// Remarks: Uses spherical development of ellipsoidal coordinates. Relative to WGS 84 / World Mercator (CRS code 3395) errors of 0.7 percent in scale and differences in northing of up to 43km in the map (equivalent to 21km on the ground) may arise.
+// Area of use: World between 85.06°S and 85.06°N.
+// Coordinate system: Cartesian 2D CS. Axes: easting, northing (X,Y). Orientations: east, north. UoM: m.
+// https://epsg.io/3857
+export var EPSG3857 = (function (Class) {
+    function EPSG3857() {
+        Class.call(this);
+        var crs = this,
+            proj = crs._proj = new SphericalMercator();
+        var c = this.c = 2 * PI * proj.options.datum.a;
+
+        // transfrom matrix
+        // Scale circumference to 1, mirror Y and shift origin to top left
+        this._tm = g.transform().translate(0.5, 0.5).scale(1 / c, -1 / c);
+
+        // Inverse transform matrix
+        this._itm = g.transform().scale(c, -c).translate(-0.5, -0.5);
+    }
+
+    if ( Class ) EPSG3857.__proto__ = Class;
+    EPSG3857.prototype = Object.create( Class && Class.prototype );
+    EPSG3857.prototype.constructor = EPSG3857;
+
+    // Location <-> Point (screen coordinates for a given scale)
+    EPSG3857.prototype.toPoint = function toPoint (loc, scale, clamp) {
+        var point = this._proj.forward(loc, clamp);
+        return point.transform(this._tm).scale(scale || 1);
+    };
+    EPSG3857.prototype.toLocation = function toLocation (point, scale, clamp) {
+        var newPoint = point.clone().scale(1 / (scale || 1)).transform(this._itm);
+        return this._proj.inverse(newPoint, clamp);
+    };
+
+    return EPSG3857;
+}(Class));
+
+// Unit: metre
+// Geodetic CRS: WGS 84
+// Scope: Very small scale mapping.
+// Remarks: Euro-centric view of world excluding polar areas.
+// Area of use: World between 80°S and 84°N.
+// Coordinate system: Cartesian 2D CS. Axes: easting, northing (E,N). Orientations: east, north. UoM: m.
+// https://epsg.io/3395
+export var EPSG3395 = (function (Class) {
+    function EPSG3395() {
+        Class.call(this);
+        this._proj = new Mercator();
+    }
+
+    if ( Class ) EPSG3395.__proto__ = Class;
+    EPSG3395.prototype = Object.create( Class && Class.prototype );
+    EPSG3395.prototype.constructor = EPSG3395;
+    EPSG3395.prototype.toPoint = function toPoint (loc) {
+        return this._proj.forward(loc);
+    };
+    EPSG3395.prototype.toLocation = function toLocation (point) {
+        return this._proj.inverse(point);
+    };
+
+    return EPSG3395;
+}(Class));
+
+// Unit: degree
+// Geodetic CRS: WGS 84
+// Scope: Horizontal component of 3D system. Used by the GPS satellite navigation system and for NATO military geodetic surveying.
+// Area of use: World.
+// Coordinate system: Ellipsoidal 2D CS. Axes: latitude, longitude. Orientations: north, east. UoM: degree
+// https://epsg.io/4326
+export var EPSG4326 = (function (Class) {
+    function EPSG4326() {
+        Class.call(this);
+        this._proj = new Equirectangular();
+    }
+
+    if ( Class ) EPSG4326.__proto__ = Class;
+    EPSG4326.prototype = Object.create( Class && Class.prototype );
+    EPSG4326.prototype.constructor = EPSG4326;
+    EPSG4326.prototype.toPoint = function toPoint (loc) {
+        return this._proj.forward(loc);
+    };
+    EPSG4326.prototype.toLocation = function toLocation (point) {
+        return this._proj.inverse(point);
+    };
+
+    return EPSG4326;
+}(Class));

package/dist/es/map/datums.js

@@ -0,0 +1,16 @@
+// Coordinate reference system
+// World Geodetic System of 1984
+var WGS84 = {
+    a: 6378137,                 // Semi-major radius
+    b: 6356752.314245179,       // Semi-minor radius
+    f: 0.0033528106647474805,   // Flattening
+    e: 0.08181919084262149      // Eccentricity
+};
+
+// Geographic coordinate systems use a spheroid to calculate positions on the earth.
+// A datum defines the position of the spheroid relative to the center of the earth
+// it provides a frame of reference for measuring locations on the surface of the earth
+// and defines the origin and orientation of latitude and longitude lines.
+export var datums = {
+    WGS84: WGS84
+};

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));