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

package/dist/es/map/utils.js

@@ -0,0 +1,459 @@
+import {
+    isFunction,
+    isArray
+} from '../common';
+
+/* eslint-disable arrow-body-style */
+
+var defineProperty = Object.defineProperty;
+
+export var extend = Object.assign;
+
+export var convertToHtml = function (html) {
+    var div = document.createElement("div");
+    div.innerHTML = html;
+    return div.firstChild;
+};
+
+export var appendHtml = function (html, element) {
+    var div = document.createElement('div');
+    div.innerHTML = html;
+
+    // use childNodes instead of children
+    // to cover text nodes as well
+    while (div.childNodes.length > 0) {
+        element.appendChild(div.childNodes[0]);
+    }
+};
+
+export var removeChildren = function (element) {
+    while (element.firstChild) {
+        element.removeChild(element.firstChild);
+    }
+};
+
+export var prepend = function (element, originElement) {
+    originElement.insertBefore(element, originElement.firstChild);
+};
+
+export var wrapInner = function (parent, wrapper) {
+    parent.appendChild(wrapper);
+
+    while (parent.firstChild !== wrapper) {
+        wrapper.appendChild(parent.firstChild);
+    }
+};
+
+export var toHyphens = function (str) {
+    var result = str.replace(/([a-z][A-Z])/g, function(g) {
+        return g.charAt(0) + '-' + g.charAt(1).toLowerCase();
+    });
+
+    return result;
+};
+
+export var toPixels = function (value) {
+    var result;
+
+    if (value && String(value).endsWith("px")) {
+        result = value;
+    } else {
+        result = String(value) + "px";
+    }
+
+    return result;
+};
+
+var detectOS = function (ua) {
+    var os = false, minorVersion, match = [],
+        // notAndroidPhone = !/mobile safari/i.test(ua),
+        agentRxs = {
+            wp: /(Windows Phone(?: OS)?)\s(\d+)\.(\d+(\.\d+)?)/,
+            fire: /(Silk)\/(\d+)\.(\d+(\.\d+)?)/,
+            android: /(Android|Android.*(?:Opera|Firefox).*?\/)\s*(\d+)\.?(\d+(\.\d+)?)?/,
+            iphone: /(iPhone|iPod).*OS\s+(\d+)[\._]([\d\._]+)/,
+            ipad: /(iPad).*OS\s+(\d+)[\._]([\d_]+)/,
+            meego: /(MeeGo).+NokiaBrowser\/(\d+)\.([\d\._]+)/,
+            webos: /(webOS)\/(\d+)\.(\d+(\.\d+)?)/,
+            blackberry: /(BlackBerry|BB10).*?Version\/(\d+)\.(\d+(\.\d+)?)/,
+            playbook: /(PlayBook).*?Tablet\s*OS\s*(\d+)\.(\d+(\.\d+)?)/,
+            windows: /(MSIE)\s+(\d+)\.(\d+(\.\d+)?)/,
+            tizen: /(tizen).*?Version\/(\d+)\.(\d+(\.\d+)?)/i,
+            sailfish: /(sailfish).*rv:(\d+)\.(\d+(\.\d+)?).*firefox/i,
+            ffos: /(Mobile).*rv:(\d+)\.(\d+(\.\d+)?).*Firefox/
+        },
+        osRxs = {
+            ios: /^i(phone|pad|pod)$/i,
+            android: /^android|fire$/i,
+            blackberry: /^blackberry|playbook/i,
+            windows: /windows/,
+            wp: /wp/,
+            flat: /sailfish|ffos|tizen/i,
+            meego: /meego/
+        },
+        formFactorRxs = {
+            tablet: /playbook|ipad|fire/i
+        },
+        browserRxs = {
+            omini: /Opera\sMini/i,
+            omobile: /Opera\sMobi/i,
+            firefox: /Firefox|Fennec/i,
+            mobilesafari: /version\/.*safari/i,
+            ie: /MSIE|Windows\sPhone/i,
+            chrome: /chrome|crios/i,
+            webkit: /webkit/i
+        };
+
+    for (var agent in agentRxs) {
+        if (agentRxs.hasOwnProperty(agent)) {
+            match = ua.match(agentRxs[agent]);
+            if (match) {
+                if (agent === "windows" && "plugins" in navigator) { return false; } // Break if not Metro/Mobile Windows
+
+                os = {};
+                os.device = agent;
+                os.tablet = testRegex(agent, formFactorRxs, false);
+                os.browser = testRegex(ua, browserRxs, "default");
+                os.name = testRegex(agent, osRxs);
+                os[os.name] = true;
+                os.majorVersion = match[2];
+                os.minorVersion = (match[3] || "0").replace("_", ".");
+                minorVersion = os.minorVersion.replace(".", "").substr(0, 2);
+                os.flatVersion = os.majorVersion + minorVersion + (new Array(3 - (minorVersion.length < 3 ? minorVersion.length : 2)).join("0"));
+
+
+                break;
+            }
+        }
+    }
+
+    return os;
+};
+
+function testRegex(agent, regexes, dflt) {
+    for (var regex in regexes) {
+        if (regexes.hasOwnProperty(regex) && regexes[regex].test(agent)) {
+            return regex;
+        }
+    }
+    return dflt !== undefined ? dflt : agent;
+}
+
+export var hasNativeScrolling = function (userAgent) {
+    var os = detectOS(userAgent);
+    return os.ios || os.android;
+};
+
+var detectBrowser = function (userAgent) {
+    var browser = false,
+        match = [],
+        browserRxs = {
+            edge: /(edge)[ \/]([\w.]+)/i,
+            webkit: /(chrome|crios)[ \/]([\w.]+)/i,
+            safari: /(webkit)[ \/]([\w.]+)/i,
+            opera: /(opera)(?:.*version|)[ \/]([\w.]+)/i,
+            msie: /(msie\s|trident.*? rv:)([\w.]+)/i,
+            mozilla: /(mozilla)(?:.*? rv:([\w.]+)|)/i
+        };
+
+    for (var agent in browserRxs) {
+        if (browserRxs.hasOwnProperty(agent)) {
+            match = userAgent.match(browserRxs[agent]);
+
+            if (match) {
+                browser = {};
+                browser[agent] = true;
+                browser[match[1].toLowerCase().split(" ")[0].split("/")[0]] = true;
+                browser.version = parseInt(document.documentMode || match[2], 10);
+
+                break;
+            }
+        }
+    }
+
+    return browser;
+};
+
+export var getEventMap = function () {
+    var eventMap = {
+        down: "touchstart mousedown",
+        move: "mousemove touchmove",
+        up: "mouseup touchend touchcancel",
+        cancel: "mouseleave touchcancel"
+    };
+
+    var support = getSupportedFeatures();
+
+    if (support.touch && (support.mobileOS.ios || support.mobileOS.android)) {
+        eventMap = {
+            down: "touchstart",
+            move: "touchmove",
+            up: "touchend touchcancel",
+            cancel: "touchcancel"
+        };
+    } else if (support.pointers) {
+        eventMap = {
+            down: "pointerdown",
+            move: "pointermove",
+            up: "pointerup",
+            cancel: "pointercancel pointerleave"
+        };
+    } else if (support.msPointers) {
+        eventMap = {
+            down: "MSPointerDown",
+            move: "MSPointerMove",
+            up: "MSPointerUp",
+            cancel: "MSPointerCancel MSPointerLeave"
+        };
+    }
+
+    return eventMap;
+};
+
+export var getSupportedFeatures = function () {
+    var os = detectOS(navigator.userAgent);
+    var browser = detectBrowser(navigator.userAgent);
+
+    var chrome = browser.chrome,
+        mobileChrome = browser.crios,
+        mozilla = browser.mozilla,
+        safari = browser.safari;
+
+    var support = {};
+
+    support.mobileOS = os;
+    support.touch = "ontouchstart" in window;
+    support.pointers = !chrome && !mobileChrome && !mozilla && !safari && window.PointerEvent;
+    support.msPointers = !chrome && window.MSPointerEvent;
+    support.mouseAndTouchPresent = support.touch && !(support.mobileOS.ios || support.mobileOS.android);
+    support.eventCapture = document.documentElement.addEventListener;
+
+    var table = document.createElement("table");
+
+    var transitions = support.transitions = false,
+        transforms = support.transforms = false;
+
+    var STRING = "string";
+
+    ["Moz", "webkit", "O", "ms"].forEach(function(prefix) {
+        var hasTransitions = typeof table.style[prefix + "Transition"] === STRING;
+
+        if (hasTransitions || typeof table.style[prefix + "Transform"] === STRING) {
+            var lowPrefix = prefix.toLowerCase();
+
+            transforms = {
+                css: (lowPrefix !== "ms") ? "-" + lowPrefix + "-" : "",
+                prefix: prefix,
+                event: (lowPrefix === "o" || lowPrefix === "webkit") ? lowPrefix : ""
+            };
+
+            if (hasTransitions) {
+                transitions = transforms;
+                transitions.event = transitions.event ? transitions.event + "TransitionEnd" : "transitionend";
+            }
+
+            return false;
+        }
+    });
+
+    table = null;
+
+    support.transforms = transforms;
+    support.transitions = transitions;
+
+    support.delayedClick = function() {
+        // only the mobile devices with touch events do this.
+        if (support.touch) {
+            // All iOS devices so far (by the time I am writing this, iOS 9.0.2 is the latest),
+            // delay their click events.
+            if (support.mobileOS.ios) {
+                return true;
+            }
+
+            if (support.mobileOS.android) {
+
+                if (!support.browser.chrome) { // older webkits and webviews delay the click
+                    return true;
+                }
+
+                // from here on, we deal with Chrome on Android.
+                if (support.browser.version < 32) {
+                    return false;
+                }
+
+                // Chrome 32+ does conditional fast clicks if the view port is not user scalable.
+                var meta = document.querySelector("meta[name=viewport]");
+                var contentAttr = meta ? meta.getAttribute("content") : "";
+                return !contentAttr.match(/user-scalable=no/i);
+            }
+        }
+
+        return false;
+    };
+
+    return support;
+};
+
+export var ownsElement = function (parent, element) {
+    if (!element) {
+        return false;
+    }
+
+    var node = element.parentNode;
+
+    while (node !== null) {
+        if (node === parent) {
+            return true;
+        }
+
+        node = node.parentNode;
+    }
+
+    return false;
+};
+
+export var contains = function (parent, element) {
+    return parent === element || ownsElement(parent, element);
+};
+
+export var proxy = function (method, context) {
+    return method.bind(context);
+};
+
+function isString(value) {
+    return typeof(value) === "string";
+}
+
+export var on = function (element, events, filter, handler, useCapture) {
+    addEventListeners(element, events, filter, handler, useCapture);
+};
+
+export var addEventListeners = function (element, events, filter, handler, useCapture) {
+    var eventNames = isArray(events) ? events : (events || "").split(" ");
+
+    eventNames.forEach(function(eventName) {
+        addEventListener(element, eventName, filter, handler, useCapture);
+    });
+};
+
+export var addEventListener = function (element, event, filter, handler, useCapture) {
+    var eventHandler = handler;
+    var eventFilter;
+
+    if (filter && isFunction(filter) && !handler) {
+        eventHandler = filter;
+    } else if (filter && isString(filter) && isFunction(eventHandler)) {
+        eventFilter = filter;
+    }
+
+    element.addEventListener(event, function(e) {
+        var closestMatchingTarget = e.target ? e.target.closest(eventFilter) : null;
+
+        if (!eventFilter ||
+            (eventFilter && e.target && closestMatchingTarget)) {
+            var currentTarget = eventFilter ? closestMatchingTarget : e.currentTarget;
+
+            // reassign the property as it is a getters only
+            defineProperty(e, "currentTarget", { value: currentTarget });
+            // keep a reference to the top-level target
+            defineProperty(e, "delegateTarget", { value: element });
+
+            eventHandler(e);
+        }
+    }, Boolean(useCapture));
+};
+
+export var off = function (element, events, filter, handler, useCapture) {
+    removeEventListeners(element, events, filter, handler, useCapture);
+};
+
+export var removeEventListeners = function (element, events, handler, useCapture) {
+    var eventNames = isArray(events) ? events : (events || "").split(" ");
+
+    eventNames.forEach(function(eventName) {
+        removeEventListener(element, eventName, handler, useCapture);
+    });
+};
+
+export var removeEventListener = function (element, event, handler, useCapture) {
+    element.removeEventListener(event, handler, Boolean(useCapture));
+};
+
+var eventMap = getEventMap(navigator.userAgent);
+
+function queryEventMap(e) {
+    return eventMap[e] || e;
+}
+
+var eventRegEx = /([^ ]+)/g;
+
+export var applyEventMap = function (events) {
+    var appliedEvents = events.replace(eventRegEx, queryEventMap);
+
+    return appliedEvents;
+};
+
+export var setDefaultEvents = function (type, events) {
+    var proto = type.prototype;
+
+    if (proto.events) {
+        events.forEach(function (event) {
+            if (proto.events.indexOf(event) < 0) {
+                proto.events.push(event);
+            }
+        });
+    } else {
+        proto.events = events;
+    }
+};
+
+export var wheelDeltaY = function (jQueryEvent) {
+    var e = jQueryEvent.originalEvent || jQueryEvent;
+    var deltaY = e.wheelDeltaY;
+    var delta;
+
+    if (e.wheelDelta) { // Webkit and IE
+        if (deltaY === undefined || deltaY) { // IE does not have deltaY, thus always scroll (horizontal scrolling is treated as vertical)
+            delta = e.wheelDelta;
+        }
+    } else if (e.detail && e.axis === e.VERTICAL_AXIS) { // Firefox and Opera
+        delta = (-e.detail) * 10;
+    }
+
+    return delta;
+};
+
+export var guid = function () {
+    var id = "";
+    var i;
+    var random;
+
+    for (i = 0; i < 32; i++) {
+        random = Math.random() * 16 | 0;
+
+        if (i === 8 || i === 12 || i === 16 || i === 20) {
+            id += "-";
+        }
+
+        id += (i === 12 ? 4 : (i === 16 ? (random & 3 | 8) : random)).toString(16); // eslint-disable-line no-nested-ternary
+    }
+
+    return id;
+};
+
+export var now = function () {
+    return Number(new Date());
+};
+
+export var elementOffset = function (element) {
+    var offset = {
+        left: element.offsetLeft,
+        top: element.offsetTop
+    };
+
+    return offset;
+};
+
+export var noop = function () {};
+
+/* eslint-enable arrow-body-style */

package/dist/es/map/zoom.js

@@ -0,0 +1,139 @@
+import {
+    deepExtend,
+    addClass,
+    keys,
+    hasClasses,
+    setDefaultOptions
+} from '../common';
+
+import {
+    Observable
+} from './scroller/observable';
+
+import {
+    on,
+    off,
+    setDefaultEvents,
+    convertToHtml
+} from './utils';
+
+function createButton(direction, iconClass) {
+    var html =
+        '<button class="k-button k-button-icon k-zoom-' + direction +
+            '" title="zoom-' + direction +
+            '" aria-label="zoom-' + direction + '">' +
+            '<span class="k-icon ' + iconClass + '">' + '</span>' +
+        '</button>';
+
+    return convertToHtml(html);
+}
+
+var PLUS = 187;
+var MINUS = 189;
+var FF_PLUS = 61;
+var FF_MINUS = 173;
+var CHANGE = "change";
+
+export var ZoomControl = (function (Observable) {
+    function ZoomControl(element, options) {
+        Observable.call(this);
+        this.element = element;
+        this._initOptions(options);
+
+        var zoomInButton = createButton('in', 'k-i-plus');
+        var zoomOutButton = createButton('out', 'k-i-minus');
+
+        this.element.appendChild(zoomInButton);
+        this.element.appendChild(zoomOutButton);
+
+        addClass(this.element, 'k-widget k-zoom-control k-button-group k-group-horizontal');
+
+        this._clickHandler = this._click.bind(this);
+        on(this.element, "click", ".k-button", this._clickHandler);
+
+        var parentElement = this.element.parentNode.closest("[data-role]");
+
+        this._keyroot = parentElement ? parentElement : this.element;
+
+        this._tabindex(this._keyroot);
+
+        this._keydownHandler = this._keydown.bind(this);
+        on(this._keyroot, "keydown", this._keydownHandler);
+    }
+
+    if ( Observable ) ZoomControl.__proto__ = Observable;
+    ZoomControl.prototype = Object.create( Observable && Observable.prototype );
+    ZoomControl.prototype.constructor = ZoomControl;
+
+    ZoomControl.prototype.destroy = function destroy () {
+        if (this.element) {
+            off(this.element, "click", this._clickHandler);
+        }
+
+        if (this._keyroot) {
+            off(this._keyroot, 'keydown', this._keydownHandler);
+        }
+    };
+
+    ZoomControl.prototype._tabindex = function _tabindex (target) {
+        var targetElement = target || this.wrapper || this.element;
+
+        var element = this.element,
+            TABINDEX = "tabindex",
+            tabindex = targetElement.getAttribute(TABINDEX) || element.getAttribute(TABINDEX);
+
+        element.removeAttribute(TABINDEX);
+
+        targetElement.setAttribute(TABINDEX, !isNaN(tabindex) ? tabindex : 0);
+    };
+
+    ZoomControl.prototype._initOptions = function _initOptions (options) {
+        this.options = deepExtend({}, this.options, options);
+    };
+
+    ZoomControl.prototype._change = function _change (direction) {
+        var zoomStep = this.options.zoomStep;
+        this.trigger(CHANGE, { delta: direction * zoomStep });
+    };
+
+    ZoomControl.prototype._click = function _click (e) {
+        var button = e.currentTarget;
+        var direction = 1;
+
+        if (hasClasses(button, 'k-zoom-out')) {
+            direction = -1;
+        }
+
+        this._change(direction);
+        e.preventDefault();
+    };
+
+    /* eslint-disable indent */
+    ZoomControl.prototype._keydown = function _keydown (e) {
+        switch (e.which) {
+            case keys.NUMPAD_PLUS:
+            case PLUS:
+            case FF_PLUS:
+                this._change(1);
+                break;
+            case keys.NUMPAD_MINUS:
+            case MINUS:
+            case FF_MINUS:
+                this._change(-1);
+                break;
+            default:
+                break;
+        }
+    };
+
+    return ZoomControl;
+}(Observable));
+
+setDefaultOptions(ZoomControl, {
+    name: 'ZoomControl',
+    zoomStep: 1
+});
+
+setDefaultEvents(ZoomControl, [
+    CHANGE
+]);

package/dist/es/map.js

@@ -0,0 +1 @@
+export { default as Map } from './map/map';

package/dist/es/services/map-service.js

@@ -0,0 +1,15 @@
+var MapService = function MapService(widget, context) {
+    if ( context === void 0 ) context = {};
+
+    this.sender = context.sender || widget;
+    this.widget = widget;
+    this.rtl = Boolean(context.rtl);
+};
+
+MapService.prototype.notify = function notify (name, args) {
+    if (this.widget) {
+        this.widget.trigger(name, args);
+    }
+};
+
+export default MapService;

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