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

package/dist/es/common/user-events.js

@@ -7,13 +7,13 @@ import now from './now';
 import grep from './grep';
 import Observable from './observable';
 
-var extend = Object.assign;
+const extend = Object.assign;
 
-var preventDefault = function (e) {
+const preventDefault = (e) => {
     e.preventDefault();
 };
 
-var
+let
     DEFAULT_MIN_HOLD = 800,
     CLICK_DELAY = 300,
     DEFAULT_THRESHOLD = 0,
@@ -32,7 +32,7 @@ var
     GESTUREEND = 'gestureend',
     GESTURETAP = 'gesturetap';
 
-var THRESHOLD = {
+let THRESHOLD = {
     'api': 0,
     'touch': 0,
     'mouse': 9,
@@ -40,7 +40,7 @@ var THRESHOLD = {
 };
 
 function touchDelta(touch1, touch2) {
-    var x1 = touch1.x.location,
+    let x1 = touch1.x.location,
         y1 = touch1.y.location,
         x2 = touch2.x.location,
         y2 = touch2.y.location,
@@ -57,7 +57,7 @@ function touchDelta(touch1, touch2) {
 }
 
 function getTouches(e) {
-    var touches = [],
+    let touches = [],
         originalEvent = e.originalEvent || e,
         currentTarget = e.currentTarget;
 
@@ -83,10 +83,10 @@ function getTouches(e) {
 
     return touches;
 }
-var TouchAxis = (function (Class) {
-    function TouchAxis(axis, location) {
-        Class.call(this);
-        var that = this;
+class TouchAxis extends Class {
+    constructor(axis, location) {
+        super();
+        let that = this;
 
         that.support = getSupportedFeatures();
         that.invalidZeroEvents = this.support.mobileOS && this.support.mobileOS.android;
@@ -97,12 +97,8 @@ var TouchAxis = (function (Class) {
         that.timeStamp = now();
     }
 
-    if ( Class ) TouchAxis.__proto__ = Class;
-    TouchAxis.prototype = Object.create( Class && Class.prototype );
-    TouchAxis.prototype.constructor = TouchAxis;
-
-    TouchAxis.prototype.move = function move (location) {
-        var that = this,
+    move(location) {
+        let that = this,
             offset = location['page' + that.axis],
             timeStamp = now(),
             timeDelta = timeStamp - that.timeStamp || 1;
@@ -116,23 +112,21 @@ var TouchAxis = (function (Class) {
         that.initialDelta = offset - that.startLocation;
         that.velocity = that.delta / timeDelta;
         that.timeStamp = timeStamp;
-    };
+    }
 
-    TouchAxis.prototype._updateLocationData = function _updateLocationData (location) {
-        var that = this,
+    _updateLocationData(location) {
+        let that = this,
             axis = that.axis;
 
         that.location = location['page' + axis];
         that.client = location['client' + axis];
         that.screen = location['screen' + axis];
-    };
-
-    return TouchAxis;
-}(Class));
+    }
+}
 
-var Touch = (function (Class) {
-    function Touch(userEvents, target, touchInfo) {
-        Class.call(this);
+class Touch extends Class {
+    constructor(userEvents, target, touchInfo) {
+        super();
 
         extend(this, {
             x: new TouchAxis('X', touchInfo.location),
@@ -152,19 +146,13 @@ var Touch = (function (Class) {
         });
     }
 
-    if ( Class ) Touch.__proto__ = Class;
-    Touch.prototype = Object.create( Class && Class.prototype );
-    Touch.prototype.constructor = Touch;
-
-    Touch.prototype.press = function press () {
-        var this$1 = this;
-
-        this._holdTimeout = setTimeout(function () { return this$1._hold(); }, this.userEvents.minHold);
+    press() {
+        this._holdTimeout = setTimeout(() => this._hold(), this.userEvents.minHold);
         this._trigger(PRESS, this.pressEvent);
-    };
+    }
 
-    Touch.prototype._tap = function _tap (touchInfo) {
-        var that = this;
+    _tap(touchInfo) {
+        let that = this;
 
         that.userEvents._clicks++;
 
@@ -179,16 +167,16 @@ var Touch = (function (Class) {
                 that.userEvents._clicks = 0;
             }, CLICK_DELAY);
         }
-    };
+    }
 
-    Touch.prototype._hold = function _hold () {
+    _hold() {
         this._trigger(HOLD, this.pressEvent);
-    };
+    }
 
     /* eslint-disable consistent-return */
-    Touch.prototype.move = function move (touchInfo) {
-        var that = this;
-        var preventMove = touchInfo.type !== 'api' && that.userEvents._shouldNotMove;
+    move(touchInfo) {
+        let that = this;
+        let preventMove = touchInfo.type !== 'api' && that.userEvents._shouldNotMove;
 
         if (that._finished || preventMove) {
             return;
@@ -212,10 +200,10 @@ var Touch = (function (Class) {
         if (!that._finished) {
             that._trigger(MOVE, touchInfo);
         }
-    };
+    }
     /* eslint-enable consistent-return */
 
-    Touch.prototype.end = function end (touchInfo) {
+    end(touchInfo) {
         this.endTime = now();
 
         if (this._finished) {
@@ -237,10 +225,10 @@ var Touch = (function (Class) {
 
         clearTimeout(this._holdTimeout);
         this.dispose();
-    };
+    }
 
-    Touch.prototype.dispose = function dispose () {
-        var userEvents = this.userEvents,
+    dispose() {
+        let userEvents = this.userEvents,
             activeTouches = userEvents.touches || [];
 
         this._finished = true;
@@ -248,32 +236,32 @@ var Touch = (function (Class) {
 
         clearTimeout(this._holdTimeout);
         // activeTouches.splice($.inArray(this, activeTouches), 1);
-        var activeTouchIndex = activeTouches.indexOf(this);
+        const activeTouchIndex = activeTouches.indexOf(this);
         activeTouches.splice(activeTouchIndex, 1);
-    };
+    }
 
-    Touch.prototype.skip = function skip () {
+    skip() {
         this.dispose();
-    };
+    }
 
-    Touch.prototype.cancel = function cancel () {
+    cancel() {
         this.dispose();
-    };
+    }
 
-    Touch.prototype.isMoved = function isMoved () {
+    isMoved() {
         return this._moved;
-    };
+    }
 
-    Touch.prototype._start = function _start (touchInfo) {
+    _start(touchInfo) {
         clearTimeout(this._holdTimeout);
         this.startTime = now();
         this._moved = true;
         this._trigger(START, touchInfo);
-    };
+    }
 
-    Touch.prototype._trigger = function _trigger (name, touchInfo) {
-        var e = touchInfo.event;
-        var data = {
+    _trigger(name, touchInfo) {
+        const e = touchInfo.event;
+        const data = {
             touch: this,
             x: this.x,
             y: this.y,
@@ -284,19 +272,17 @@ var Touch = (function (Class) {
         if (this.userEvents.notify(name, data)) {
             e.preventDefault();
         }
-    };
+    }
 
-    Touch.prototype._withinIgnoreThreshold = function _withinIgnoreThreshold () {
-        var xDelta = this.x.initialDelta,
+    _withinIgnoreThreshold() {
+        let xDelta = this.x.initialDelta,
             yDelta = this.y.initialDelta;
         return Math.sqrt(xDelta * xDelta + yDelta * yDelta) <= this.threshold;
-    };
-
-    return Touch;
-}(Class));
+    }
+}
 
 function withEachUpEvent(callback) {
-    var downEvents = eventMap.up.split(' '),
+    let downEvents = eventMap.up.split(' '),
         idx = 0,
         length = downEvents.length;
 
@@ -305,13 +291,13 @@ function withEachUpEvent(callback) {
     }
 }
 
-var UserEvents = (function (Observable) {
-    function UserEvents(element, options) {
-        Observable.call(this);
-        var that = this;
-        var filter;
+export default class UserEvents extends Observable {
+    constructor(element, options) {
+        super();
+        let that = this;
+        let filter;
 
-        var support = getSupportedFeatures();
+        const support = getSupportedFeatures();
         this.support = support;
 
         /* eslint-disable no-param-reassign */
@@ -361,7 +347,7 @@ var UserEvents = (function (Observable) {
         on(element, applyEventMap('mousedown'), filter, this._elementSelectHandler);
 
         if (that.captureUpIfMoved) {
-            var surfaceElement = that.surface;
+            let surfaceElement = that.surface;
             that._preventIfMovingProxy = that.preventIfMoving.bind(that);
 
             withEachUpEvent(function(eventName) {
@@ -387,20 +373,16 @@ var UserEvents = (function (Observable) {
         ], options);
     }
 
-    if ( Observable ) UserEvents.__proto__ = Observable;
-    UserEvents.prototype = Object.create( Observable && Observable.prototype );
-    UserEvents.prototype.constructor = UserEvents;
-
-    UserEvents.prototype.preventIfMoving = function preventIfMoving (e) {
+    preventIfMoving(e) {
         if (this._isMoved()) {
             e.preventDefault();
         }
-    };
+    }
 
-    UserEvents.prototype.destroy = function destroy () {
-        var that = this;
-        var options = this.options;
-        var element = this.element;
+    destroy() {
+        let that = this;
+        const options = this.options;
+        const element = this.element;
 
         if (that._destroyed) {
             return;
@@ -409,7 +391,7 @@ var UserEvents = (function (Observable) {
         that._destroyed = true;
 
         if (that.captureUpIfMoved) {
-            var surfaceElement = that.surface;
+            let surfaceElement = that.surface;
             withEachUpEvent(function(eventName) {
                 surfaceElement.removeEventListener(eventName, that._preventIfMovingProxy, true);
             });
@@ -432,21 +414,21 @@ var UserEvents = (function (Observable) {
         delete that.surface;
         delete that.element;
         delete that.currentTarget;
-    };
+    }
 
-    UserEvents.prototype.capture = function capture () {
+    capture() {
         UserEvents.current = this;
-    };
+    }
 
-    UserEvents.prototype.cancel = function cancel () {
+    cancel() {
         this._disposeAll();
         this.trigger(CANCEL);
-    };
+    }
 
-    UserEvents.prototype.notify = function notify (event, data) {
-        var that = this,
+    notify(event, data) {
+        let that = this,
             touches = that.touches;
-        var eventName = event;
+        let eventName = event;
 
         if (this._isMultiTouch()) {
             switch (eventName) {
@@ -471,50 +453,48 @@ var UserEvents = (function (Observable) {
         return this.trigger(eventName, extend(data, {
             type: eventName
         }));
-    };
+    }
 
-    UserEvents.prototype.press = function press (x, y, target) {
+    press(x, y, target) {
         this._apiCall('_start', x, y, target);
-    };
+    }
 
-    UserEvents.prototype.move = function move (x, y) {
+    move(x, y) {
         this._apiCall('_move', x, y);
-    };
+    }
 
-    UserEvents.prototype.end = function end (x, y) {
+    end(x, y) {
         this._apiCall('_end', x, y);
-    };
+    }
 
-    UserEvents.prototype._isMultiTouch = function _isMultiTouch () {
+    _isMultiTouch() {
         return this.touches.length > 1;
-    };
+    }
 
-    UserEvents.prototype._maxTouchesReached = function _maxTouchesReached () {
+    _maxTouchesReached() {
         return this.touches.length >= this._maxTouches;
-    };
+    }
 
-    UserEvents.prototype._disposeAll = function _disposeAll () {
-        var touches = this.touches;
+    _disposeAll() {
+        let touches = this.touches;
         while (touches.length > 0) {
             touches.pop().dispose();
         }
-    };
+    }
 
-    UserEvents.prototype._isMoved = function _isMoved () {
+    _isMoved() {
         return grep(this.touches, function(touch) {
             return touch.isMoved();
         }).length;
-    };
+    }
 
-    UserEvents.prototype._select = function _select (e) {
+    _select(e) {
         if (!this.allowSelection || this.trigger(SELECT, { event: e })) {
             e.preventDefault();
         }
-    };
-
-    UserEvents.prototype._start = function _start (e) {
-        var this$1 = this;
+    }
 
+    _start(e) {
         if (e.which && e.which > 1 || this._maxTouchesReached()) {
             return;
         }
@@ -526,46 +506,44 @@ var UserEvents = (function (Observable) {
             e.stopPropagation();
         }
 
-        var target;
-        var eventTouches = getTouches(e);
-        for (var idx = 0; idx < eventTouches.length; idx++) {
-            if (this$1._maxTouchesReached()) {
+        let target;
+        const eventTouches = getTouches(e);
+        for (let idx = 0; idx < eventTouches.length; idx++) {
+            if (this._maxTouchesReached()) {
                 break;
             }
 
-            var eventTouch = eventTouches[idx];
-            if (this$1.filter) {
+            const eventTouch = eventTouches[idx];
+            if (this.filter) {
                 target = eventTouch.currentTarget;
             } else {
-                target = this$1.element;
+                target = this.element;
             }
 
             if (target && target.length === 0) {
                 continue;
             }
 
-            var touch = new Touch(this$1, target, eventTouch);
-            this$1.touches.push(touch);
+            const touch = new Touch(this, target, eventTouch);
+            this.touches.push(touch);
             touch.press();
 
-            if (this$1._isMultiTouch()) {
-                this$1.notify('gesturestart', {});
+            if (this._isMultiTouch()) {
+                this.notify('gesturestart', {});
             }
         }
-    };
+    }
 
-    UserEvents.prototype._move = function _move (e) {
+    _move(e) {
         this._eachTouch('move', e);
-    };
+    }
 
-    UserEvents.prototype._end = function _end (e) {
+    _end(e) {
         this._eachTouch('end', e);
-    };
-
-    UserEvents.prototype._eachTouch = function _eachTouch (methodName, e) {
-        var this$1 = this;
+    }
 
-        var that = this,
+    _eachTouch(methodName, e) {
+        let that = this,
             dict = {},
             touches = getTouches(e),
             activeTouches = that.touches,
@@ -584,17 +562,17 @@ var UserEvents = (function (Observable) {
             matchingTouch = dict[touchInfo.id];
 
             if (matchingTouch) {
-                var shouldCapture = methodName === 'move' && touchInfo.type === 'pointer' && !this$1.surface.hasPointerCapture(touchInfo.id);
+                const shouldCapture = methodName === 'move' && touchInfo.type === 'pointer' && !this.surface.hasPointerCapture(touchInfo.id);
                 if (shouldCapture) {
-                    this$1.surface.setPointerCapture(touchInfo.id);
+                    this.surface.setPointerCapture(touchInfo.id);
                 }
 
                 matchingTouch[methodName](touchInfo);
             }
         }
-    };
+    }
 
-    UserEvents.prototype._apiCall = function _apiCall (type, x, y, target) {
+    _apiCall(type, x, y, target) {
         this[type]({
             api: true,
             pageX: x,
@@ -605,17 +583,13 @@ var UserEvents = (function (Observable) {
             stopPropagation: noop,
             preventDefault: noop
         });
-    };
+    }
 
-    UserEvents.defaultThreshold = function defaultThreshold (value) {
+    static defaultThreshold(value) {
         DEFAULT_THRESHOLD = value;
-    };
+    }
 
-    UserEvents.minHold = function minHold (value) {
+    static minHold(value) {
         DEFAULT_MIN_HOLD = value;
-    };
-
-    return UserEvents;
-}(Observable));
-
-export default UserEvents;
+    }
+}

package/dist/es/core/axis-label.js

@@ -9,9 +9,9 @@ import { AXIS_LABEL_CLICK, CENTER, TOP, BOTTOM, LEFT, DEFAULT_PRECISION, X, Y }
 
 import { eventElement, round, setDefaultOptions } from '../common';
 
-var AxisLabel = (function (TextBox) {
-    function AxisLabel(value, text, index, dataItem, options) {
-        TextBox.call(this, text, options);
+class AxisLabel extends TextBox {
+    constructor(value, text, index, dataItem, options) {
+        super(text, options);
 
         this.text = text;
         this.value = value;
@@ -20,12 +20,8 @@ var AxisLabel = (function (TextBox) {
         this.reflow(new Box());
     }
 
-    if ( TextBox ) AxisLabel.__proto__ = TextBox;
-    AxisLabel.prototype = Object.create( TextBox && TextBox.prototype );
-    AxisLabel.prototype.constructor = AxisLabel;
-
-    AxisLabel.prototype.visualContext = function visualContext (targetBox) {
-        var context = TextBox.prototype.visualContext.call(this, targetBox);
+    visualContext(targetBox) {
+        const context = super.visualContext(targetBox);
 
         context.value = this.value;
         context.dataItem = this.dataItem;
@@ -33,9 +29,9 @@ var AxisLabel = (function (TextBox) {
         context.culture = this.options.culture;
 
         return context;
-    };
+    }
 
-    AxisLabel.prototype.click = function click (widget, e) {
+    click(widget, e) {
 
         widget.trigger(AXIS_LABEL_CLICK, {
             element: eventElement(e),
@@ -45,54 +41,55 @@ var AxisLabel = (function (TextBox) {
             dataItem: this.dataItem,
             axis: this.parent.options
         });
-    };
+    }
 
-    AxisLabel.prototype.rotate = function rotate () {
+    rotate() {
         if (this.options.alignRotation !== CENTER) {
-            var box = this.normalBox.toRect();
-            var transform = this.rotationTransform();
+            const box = this.normalBox.toRect();
+            const transform = this.rotationTransform();
 
             this.box = rectToBox(box.bbox(transform.matrix()));
         } else {
-            TextBox.prototype.rotate.call(this);
+            super.rotate();
         }
 
         return this.box;
-    };
+    }
 
-    AxisLabel.prototype.rotationTransform = function rotationTransform () {
-        var options = this.options;
-        var rotation = options.rotation;
+    rotationTransform() {
+        const options = this.options;
+        const rotation = options.rotation;
         if (!rotation) {
             return null;
         }
 
         if (options.alignRotation === CENTER) {
-            return TextBox.prototype.rotationTransform.call(this);
+            return super.rotationTransform();
         }
 
-        var rotationMatrix = geom.transform().rotate(rotation).matrix();
-        var box = this.normalBox.toRect();
-        var rect = this.targetBox.toRect();
+        const rotationMatrix = geom.transform().rotate(rotation).matrix();
+        const box = this.normalBox.toRect();
+        const rect = this.targetBox.toRect();
 
-        var rotationOrigin = options.rotationOrigin || TOP;
-        var alignAxis = rotationOrigin === TOP || rotationOrigin === BOTTOM ? X : Y;
-        var distanceAxis = rotationOrigin === TOP || rotationOrigin === BOTTOM ? Y : X;
-        var axisAnchor = rotationOrigin === TOP || rotationOrigin === LEFT ? rect.origin : rect.bottomRight();
+        const rotationOrigin = options.rotationOrigin || TOP;
+        const alignAxis = rotationOrigin === TOP || rotationOrigin === BOTTOM ? X : Y;
+        const distanceAxis = rotationOrigin === TOP || rotationOrigin === BOTTOM ? Y : X;
+        const axisAnchor = rotationOrigin === TOP || rotationOrigin === LEFT ? rect.origin : rect.bottomRight();
 
-        var topLeft = box.topLeft().transformCopy(rotationMatrix);
-        var topRight = box.topRight().transformCopy(rotationMatrix);
-        var bottomRight = box.bottomRight().transformCopy(rotationMatrix);
-        var bottomLeft = box.bottomLeft().transformCopy(rotationMatrix);
-        var rotatedBox = geom.Rect.fromPoints(topLeft, topRight, bottomRight, bottomLeft);
+        const topLeft = box.topLeft().transformCopy(rotationMatrix);
+        const topRight = box.topRight().transformCopy(rotationMatrix);
+        const bottomRight = box.bottomRight().transformCopy(rotationMatrix);
+        const bottomLeft = box.bottomLeft().transformCopy(rotationMatrix);
+        const rotatedBox = geom.Rect.fromPoints(topLeft, topRight, bottomRight, bottomLeft);
 
-        var translate = {};
-        translate[distanceAxis] = rect.origin[distanceAxis] - rotatedBox.origin[distanceAxis];
+        const translate = {
+            [distanceAxis]: rect.origin[distanceAxis] - rotatedBox.origin[distanceAxis]
+        };
 
-        var distanceLeft = Math.abs(topLeft[distanceAxis] + translate[distanceAxis] - axisAnchor[distanceAxis]);
-        var distanceRight = Math.abs(topRight[distanceAxis] + translate[distanceAxis] - axisAnchor[distanceAxis]);
+        const distanceLeft = Math.abs(topLeft[distanceAxis] + translate[distanceAxis] - axisAnchor[distanceAxis]);
+        const distanceRight = Math.abs(topRight[distanceAxis] + translate[distanceAxis] - axisAnchor[distanceAxis]);
 
-        var alignStart, alignEnd;
+        let alignStart, alignEnd;
 
         if (round(distanceLeft, DEFAULT_PRECISION) === round(distanceRight, DEFAULT_PRECISION)) {
             alignStart = topLeft;
@@ -105,16 +102,14 @@ var AxisLabel = (function (TextBox) {
             alignEnd = bottomLeft;
         }
 
-        var alignCenter = alignStart[alignAxis] + (alignEnd[alignAxis] - alignStart[alignAxis]) / 2;
+        const alignCenter = alignStart[alignAxis] + (alignEnd[alignAxis] - alignStart[alignAxis]) / 2;
         translate[alignAxis] = rect.center()[alignAxis] - alignCenter;
 
         return geom.transform()
             .translate(translate.x, translate.y)
             .rotate(rotation);
-    };
-
-    return AxisLabel;
-}(TextBox));
+    }
+}
 
 setDefaultOptions(AxisLabel, {
     _autoReflow: false