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

package/dist/es2015/common/keys.js

@@ -0,0 +1,25 @@
+let 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/es2015/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/es2015/drawing-utils.js

@@ -1,5 +1,45 @@
-import { drawing, Class, logToConsole } from '@progress/kendo-drawing';
+import {
+    drawing,
+    Class,
+    logToConsole
+} from '@progress/kendo-drawing';
 
-const { append, bindEvents, defined, deg, elementOffset, elementSize, eventElement, eventCoordinates, last, limitValue, objectKey, rad, round, unbindEvents, valueOrDefault } = drawing.util;
+const {
+    append,
+    bindEvents,
+    defined,
+    deg,
+    elementOffset,
+    elementSize,
+    eventCoordinates,
+    eventElement,
+    hashKey,
+    last,
+    limitValue,
+    objectKey,
+    rad,
+    round,
+    unbindEvents,
+    valueOrDefault
+} = drawing.util;
 
-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/es2015/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/es2015/map/attribution.js

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

package/dist/es2015/map/crs.js

@@ -0,0 +1,233 @@
+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';
+
+
+let math = Math,
+    atan = math.atan,
+    exp = math.exp,
+    pow = math.pow,
+    sin = math.sin,
+    log = math.log,
+    tan = math.tan,
+    Point = g.Point;
+
+let PI = math.PI,
+    PI_DIV_2 = PI / 2,
+    PI_DIV_4 = PI / 4,
+    DEG_TO_RAD = PI / 180;
+
+let WGS84 = datums.WGS84;
+
+// WGS 84 / World Mercator
+export class Mercator extends Class {
+    constructor(options) {
+        super();
+        this.initProperties();
+        this._initOptions(options);
+    }
+
+    _initOptions(options) {
+        this.options = deepExtend({}, this.options, options);
+    }
+
+    initProperties() {
+        // super.initProperties();
+
+        deepExtend(this, {
+            MAX_LNG: 180,
+            MAX_LAT: 85.0840590501,
+            INVERSE_ITERATIONS: 15,
+            INVERSE_CONVERGENCE: 1e-12
+        });
+    }
+
+    forward(loc, clamp) {
+        let 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);
+    }
+    _projectLat(lat) {
+        let 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);
+    }
+    inverse(point, clamp) {
+        let 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);
+    }
+    _inverseY(y) {
+        let 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++) {
+            let 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);
+    }
+}
+
+setDefaultOptions(Mercator, {
+    centralMeridian: 0,
+    datum: WGS84
+});
+
+
+// WGS 84 / Pseudo-Mercator
+// Used by Google Maps, Bing, OSM, etc.
+// Spherical projection of ellipsoidal coordinates.
+export class SphericalMercator extends Mercator {
+    initProperties() {
+        super.initProperties();
+
+        deepExtend(this, {
+            MAX_LAT: 85.0511287798
+        });
+    }
+
+    _projectLat(lat) {
+        let r = this.options.datum.a,
+            y = rad(lat),
+            ts = tan(PI_DIV_4 + y / 2);
+        return r * log(ts);
+    }
+
+    _inverseY(y) {
+        let r = this.options.datum.a,
+            ts = exp(-y / r);
+        return deg(PI_DIV_2 - 2 * atan(ts));
+    }
+}
+
+export class Equirectangular extends Class {
+    forward(loc) {
+        return new Point(loc.lng, loc.lat);
+    }
+    inverse(point) {
+        return new Location(point.y, point.x);
+    }
+}
+
+// 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 class EPSG3857 extends Class {
+    constructor() {
+        super();
+        let crs = this,
+            proj = crs._proj = new SphericalMercator();
+        let 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);
+    }
+
+    // Location <-> Point (screen coordinates for a given scale)
+    toPoint(loc, scale, clamp) {
+        let point = this._proj.forward(loc, clamp);
+        return point.transform(this._tm).scale(scale || 1);
+    }
+    toLocation(point, scale, clamp) {
+        let newPoint = point.clone().scale(1 / (scale || 1)).transform(this._itm);
+        return this._proj.inverse(newPoint, clamp);
+    }
+}
+
+// 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 class EPSG3395 extends Class {
+    constructor() {
+        super();
+        this._proj = new Mercator();
+    }
+    toPoint(loc) {
+        return this._proj.forward(loc);
+    }
+    toLocation(point) {
+        return this._proj.inverse(point);
+    }
+}
+
+// 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 class EPSG4326 extends Class {
+    constructor() {
+        super();
+        this._proj = new Equirectangular();
+    }
+    toPoint(loc) {
+        return this._proj.forward(loc);
+    }
+    toLocation(point) {
+        return this._proj.inverse(point);
+    }
+}

package/dist/es2015/map/datums.js

@@ -0,0 +1,16 @@
+// Coordinate reference system
+// World Geodetic System of 1984
+const 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 const datums = {
+    WGS84
+};

package/dist/es2015/map/extent.js

@@ -0,0 +1,115 @@
+import {
+    Class,
+    valueOrDefault
+} from '../common';
+
+import { Location } from './location';
+
+let math = Math,
+    max = math.max,
+    min = math.min;
+
+export class Extent extends Class {
+    constructor(initialNw, initialSe) {
+        super();
+        let nw = Location.create(initialNw);
+        let 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;
+        }
+    }
+
+    contains(loc) {
+        let 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;
+    }
+
+    center() {
+        let nw = this.nw;
+        let se = this.se;
+        let lng = nw.lng + (se.lng - nw.lng) / 2;
+        let lat = nw.lat + (se.lat - nw.lat) / 2;
+
+        return new Location(lat, lng);
+    }
+
+    containsAny(locs) {
+        let result = false;
+
+        for (let i = 0; i < locs.length; i++) {
+            result = result || this.contains(locs[i]);
+        }
+
+        return result;
+    }
+
+    include(loc) {
+        let 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);
+    }
+
+    includeAll(locs) {
+        for (let i = 0; i < locs.length; i++) {
+            this.include(locs[i]);
+        }
+    }
+
+    edges() {
+        let 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)
+        };
+    }
+
+    toArray() {
+        let nw = this.nw, se = this.se;
+
+        return [
+            nw,
+            new Location(nw.lat, se.lng),
+            se,
+            new Location(se.lat, nw.lng)
+        ];
+    }
+
+    overlaps(extent) {
+        return this.containsAny(extent.toArray()) ||
+            extent.containsAny(this.toArray());
+    }
+
+    static 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]
+            ]);
+        }
+    }
+
+    static get World() {
+        return new Extent([ 90, -180 ], [ -90, 180 ]);
+    }
+}