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

package/dist/es/map/scroller/scroller.js

@@ -34,7 +34,7 @@ import {
     TapCapture
 } from './draggable';
 
-var
+let
     extend = Object.assign,
     abs = Math.abs,
     SNAPBACK_DURATION = 500,
@@ -52,52 +52,46 @@ var
     SCROLL = 'scroll',
     MOUSE_WHEEL_ID = 2;
 
-var ZoomSnapBack = (function (Animation) {
-    function ZoomSnapBack(options) {
-        Animation.call(this, options);
-        var that = this;
+class ZoomSnapBack extends Animation {
+    constructor(options) {
+        super(options);
+        let that = this;
         extend(that, options);
         that.userEvents.bind('gestureend', that.start.bind(this));
         that.tapCapture.bind('press', that.cancel.bind(this));
     }
 
-    if ( Animation ) ZoomSnapBack.__proto__ = Animation;
-    ZoomSnapBack.prototype = Object.create( Animation && Animation.prototype );
-    ZoomSnapBack.prototype.constructor = ZoomSnapBack;
-
-    ZoomSnapBack.prototype.enabled = function enabled () {
+    enabled() {
         return this.movable.scale < this.dimensions.minScale;
-    };
+    }
 
-    ZoomSnapBack.prototype.done = function done () {
+    done() {
         return this.dimensions.minScale - this.movable.scale < 0.01;
-    };
+    }
 
-    ZoomSnapBack.prototype.tick = function tick () {
-        var movable = this.movable;
+    tick() {
+        let movable = this.movable;
         movable.scaleWith(1.1);
         this.dimensions.rescale(movable.scale);
-    };
+    }
 
-    ZoomSnapBack.prototype.onEnd = function onEnd () {
-        var movable = this.movable;
+    onEnd() {
+        let movable = this.movable;
         movable.scaleTo(this.dimensions.minScale);
         this.dimensions.rescale(movable.scale);
-    };
-
-    return ZoomSnapBack;
-}(Animation));
+    }
+}
 
-var DragInertia = (function (Animation) {
-    function DragInertia(options) {
-        Animation.call(this);
-        var that = this;
+class DragInertia extends Animation {
+    constructor(options) {
+        super();
+        let that = this;
 
         extend(that, options, {
             transition: new Transition({
                 axis: options.axis,
                 movable: options.movable,
-                onEnd: function onEnd() {
+                onEnd() {
                     that._end();
                 }
             })
@@ -112,35 +106,31 @@ var DragInertia = (function (Animation) {
         that.userEvents.bind('tap', proxy(that.onEnd, that));
     }
 
-    if ( Animation ) DragInertia.__proto__ = Animation;
-    DragInertia.prototype = Object.create( Animation && Animation.prototype );
-    DragInertia.prototype.constructor = DragInertia;
-
-    DragInertia.prototype.onCancel = function onCancel () {
+    onCancel() {
         this.transition.cancel();
-    };
+    }
 
-    DragInertia.prototype.freeze = function freeze (location) {
-        var that = this;
+    freeze(location) {
+        let that = this;
         that.cancel();
         that._moveTo(location);
-    };
+    }
 
-    DragInertia.prototype.onEnd = function onEnd () {
-        var that = this;
+    onEnd() {
+        let that = this;
         if (that.paneAxis.outOfBounds()) {
             that._snapBack();
         } else {
             that._end();
         }
-    };
+    }
 
-    DragInertia.prototype.done = function done () {
+    done() {
         return abs(this.velocity) < 1;
-    };
+    }
 
-    DragInertia.prototype.start = function start (e) {
-        var that = this,
+    start(e) {
+        let that = this,
             velocity;
         if (!that.dimension.enabled) {
             return;
@@ -149,7 +139,7 @@ var DragInertia = (function (Animation) {
             if (that.transition._started) {
                 that.transition.cancel();
                 that.velocity = Math.min(e.touch[that.axis].velocity * that.velocityMultiplier, MAX_VELOCITY);
-                Animation.prototype.start.call(this);
+                super.start();
             } else {
                 that._snapBack();
             }
@@ -157,12 +147,12 @@ var DragInertia = (function (Animation) {
             velocity = e.touch.id === MOUSE_WHEEL_ID ? 0 : e.touch[that.axis].velocity;
             that.velocity = Math.max(Math.min(velocity * that.velocityMultiplier, MAX_VELOCITY), -MAX_VELOCITY);
             that.tapCapture.captureNext();
-            Animation.prototype.start.call(this);
+            super.start();
         }
-    };
+    }
 
-    DragInertia.prototype.tick = function tick () {
-        var that = this,
+    tick() {
+        let that = this,
             dimension = that.dimension,
             friction = that.paneAxis.outOfBounds() ? OUT_OF_BOUNDS_FRICTION : that.friction,
             delta = that.velocity *= friction,
@@ -174,36 +164,34 @@ var DragInertia = (function (Animation) {
         }
 
         that.movable.moveAxis(that.axis, location);
-    };
+    }
 
-    DragInertia.prototype._end = function _end () {
+    _end() {
         this.tapCapture.cancelCapture();
         this.end();
-    };
+    }
 
-    DragInertia.prototype._snapBack = function _snapBack () {
-        var that = this,
+    _snapBack() {
+        let that = this,
             dimension = that.dimension,
             snapBack = that.movable[that.axis] > dimension.max ? dimension.max : dimension.min;
 
         that._moveTo(snapBack);
-    };
+    }
 
-    DragInertia.prototype._moveTo = function _moveTo (location) {
+    _moveTo(location) {
         this.transition.moveTo({
             location: location,
             duration: SNAPBACK_DURATION,
             ease: Transition.easeOutExpo
         });
-    };
-
-    return DragInertia;
-}(Animation));
+    }
+}
 
-var AnimatedScroller = (function (Animation) {
-    function AnimatedScroller(options) {
-        Animation.call(this, options);
-        var that = this;
+class AnimatedScroller extends Animation {
+    constructor(options) {
+        super(options);
+        let that = this;
 
         extend(that, options, {
             origin: {},
@@ -212,43 +200,39 @@ var AnimatedScroller = (function (Animation) {
         });
     }
 
-    if ( Animation ) AnimatedScroller.__proto__ = Animation;
-    AnimatedScroller.prototype = Object.create( Animation && Animation.prototype );
-    AnimatedScroller.prototype.constructor = AnimatedScroller;
-
-    AnimatedScroller.prototype.tick = function tick () {
+    tick() {
         this._updateCoordinates();
         this.moveTo(this.origin);
-    };
+    }
 
-    AnimatedScroller.prototype.done = function done () {
+    done() {
         return abs(this.offset.y) < ANIMATED_SCROLLER_PRECISION && abs(this.offset.x) < ANIMATED_SCROLLER_PRECISION;
-    };
+    }
 
-    AnimatedScroller.prototype.onEnd = function onEnd () {
+    onEnd() {
         this.moveTo(this.destination);
         if (this.callback) {
             this.callback.call();
         }
-    };
+    }
 
-    AnimatedScroller.prototype.setCoordinates = function setCoordinates (from, to) {
+    setCoordinates(from, to) {
         this.offset = {};
         this.origin = from;
         this.destination = to;
-    };
+    }
 
     /* eslint-disable no-param-reassign */
-    AnimatedScroller.prototype.setCallback = function setCallback (callback) {
+    setCallback(callback) {
         if (callback && isFunction(callback)) {
             this.callback = callback;
         } else {
             callback = undefined;
         }
-    };
+    }
     /* eslint-enable no-param-reassign */
 
-    AnimatedScroller.prototype._updateCoordinates = function _updateCoordinates () {
+    _updateCoordinates() {
         this.offset = {
             x: (this.destination.x - this.origin.x) / 4,
             y: (this.destination.y - this.origin.y) / 4
@@ -257,19 +241,17 @@ var AnimatedScroller = (function (Animation) {
             y: this.origin.y + this.offset.y,
             x: this.origin.x + this.offset.x
         };
-    };
-
-    return AnimatedScroller;
-}(Animation));
+    }
+}
 
-var ScrollBar = (function (Class) {
-    function ScrollBar(options) {
-        Class.call(this);
-        var that = this,
+class ScrollBar extends Class {
+    constructor(options) {
+        super();
+        let that = this,
             horizontal = options.axis === 'x';
 
-        var orientation = (horizontal ? 'horizontal' : 'vertical');
-        var element = convertToHtml('<div class="km-touch-scrollbar km-' + orientation + '-scrollbar" />');
+        const orientation = (horizontal ? 'horizontal' : 'vertical');
+        const element = convertToHtml('<div class="km-touch-scrollbar km-' + orientation + '-scrollbar" />');
 
         extend(that, options, {
             element: element,
@@ -289,12 +271,8 @@ var ScrollBar = (function (Class) {
         }
     }
 
-    if ( Class ) ScrollBar.__proto__ = Class;
-    ScrollBar.prototype = Object.create( Class && Class.prototype );
-    ScrollBar.prototype.constructor = ScrollBar;
-
-    ScrollBar.prototype.refresh = function refresh () {
-        var that = this,
+    refresh() {
+        let that = this,
             axis = that.axis,
             dimension = that.dimension,
             paneSize = dimension.size,
@@ -318,34 +296,32 @@ var ScrollBar = (function (Class) {
             that.elementSize = size;
         }
         that.movable.moveAxis(axis, position);
-    };
+    }
 
-    ScrollBar.prototype.show = function show () {
+    show() {
         this.element.style.opacity = SCROLLBAR_OPACITY;
         this.element.style.visibility = "visible";
-    };
+    }
 
-    ScrollBar.prototype.hide = function hide () {
+    hide() {
         if (!this.alwaysVisible) {
             this.element.style.opacity = 0;
         }
-    };
-
-    return ScrollBar;
-}(Class));
+    }
+}
 
 // export class Scroller extends Class {
-export var Scroller = (function (Observable) {
-    function Scroller(element, options) {
-        Observable.call(this);
-        var that = this;
+export class Scroller extends Observable {
+    constructor(element, options) {
+        super();
+        let that = this;
         this.element = element;
 
         this._initOptions(options);
 
-        var hasScrolling = hasNativeScrolling(navigator.userAgent);
+        const hasScrolling = hasNativeScrolling(navigator.userAgent);
         that._native = that.options.useNative && hasScrolling;
-        var scrollHeader = convertToHtml('<div class="km-scroll-header"/>');
+        const scrollHeader = convertToHtml('<div class="km-scroll-header"/>');
 
         if (that._native) {
             addClass(element, 'km-native-scroller');
@@ -362,11 +338,11 @@ export var Scroller = (function (Observable) {
         element.style.overflow = "hidden";
         addClass(element, 'km-scroll-wrapper');
 
-        var scrollContainer = convertToHtml('<div class="km-scroll-container"/>');
+        const scrollContainer = convertToHtml('<div class="km-scroll-container"/>');
         wrapInner(element, scrollContainer);
         prepend(scrollHeader, element);
 
-        var inner = element.children[1],
+        let inner = element.children[1],
             tapCapture = new TapCapture(element),
             movable = new Movable(inner),
 
@@ -384,9 +360,9 @@ export var Scroller = (function (Observable) {
                 captureUpIfMoved: true,
                 multiTouch: that.options.zoom,
                 supportDoubleTap: that.options.supportDoubleTap,
-                start: function start(e) {
+                start(e) {
                     dimensions.refresh();
-                    var velocityX = abs(e.x.velocity),
+                    let velocityX = abs(e.x.velocity),
                         velocityY = abs(e.y.velocity),
                         horizontalSwipe = velocityX * 2 >= velocityY,
                         originatedFromFixedContainer = that.fixedContainer.contains(e.event.target),
@@ -414,7 +390,7 @@ export var Scroller = (function (Observable) {
             }),
 
             animatedScroller = new AnimatedScroller({
-                moveTo: function moveTo(coordinates) {
+                moveTo(coordinates) {
                     that.scrollTo(coordinates.x, coordinates.y);
                 }
             });
@@ -464,15 +440,11 @@ export var Scroller = (function (Observable) {
         }
     }
 
-    if ( Observable ) Scroller.__proto__ = Observable;
-    Scroller.prototype = Object.create( Observable && Observable.prototype );
-    Scroller.prototype.constructor = Scroller;
-
-    Scroller.prototype._initOptions = function _initOptions (options) {
+    _initOptions(options) {
         this.options = deepExtend({}, this.options, options);
-    };
+    }
 
-    Scroller.prototype._wheelScroll = function _wheelScroll (e) {
+    _wheelScroll(e) {
         if (e.ctrlKey) {
             return;
         }
@@ -484,7 +456,7 @@ export var Scroller = (function (Observable) {
 
         clearTimeout(this._wheelTimeout);
         this._wheelTimeout = setTimeout(this._wheelEnd, 50);
-        var delta = wheelDeltaY(e);
+        let delta = wheelDeltaY(e);
 
         if (delta) {
             this._wheelY += delta;
@@ -492,45 +464,45 @@ export var Scroller = (function (Observable) {
         }
 
         e.preventDefault();
-    };
+    }
 
-    Scroller.prototype.makeVirtual = function makeVirtual () {
+    makeVirtual() {
         this.dimensions.y.makeVirtual();
-    };
+    }
 
-    Scroller.prototype.virtualSize = function virtualSize (min, max) {
+    virtualSize(min, max) {
         this.dimensions.y.virtualSize(min, max);
-    };
+    }
 
-    Scroller.prototype.height = function height () {
+    height() {
         return this.dimensions.y.size;
-    };
+    }
 
-    Scroller.prototype.scrollHeight = function scrollHeight () {
+    scrollHeight() {
         return this.scrollElement.scrollHeight;
-    };
+    }
 
-    Scroller.prototype.scrollWidth = function scrollWidth () {
+    scrollWidth() {
         return this.scrollElement.scrollWidth;
-    };
+    }
 
-    Scroller.prototype._resize = function _resize () {
+    _resize() {
         if (!this._native) {
             this.contentResized();
         }
-    };
+    }
 
-    Scroller.prototype.setOptions = function setOptions (options) {
-        var that = this;
+    setOptions(options) {
+        let that = this;
 
         this._initOptions(options);
 
         if (options.pullToRefresh) {
             that._initPullToRefresh();
         }
-    };
+    }
 
-    Scroller.prototype.reset = function reset () {
+    reset() {
         if (this._native) {
             this.scrollElement.scrollTop(0);
         } else {
@@ -540,9 +512,9 @@ export var Scroller = (function (Observable) {
             });
             this._scale(1);
         }
-    };
+    }
 
-    Scroller.prototype.contentResized = function contentResized () {
+    contentResized() {
         this.dimensions.refresh();
         if (this.pane.x.outOfBounds()) {
             this.movable.moveAxis('x', this.dimensions.x.min);
@@ -550,24 +522,24 @@ export var Scroller = (function (Observable) {
         if (this.pane.y.outOfBounds()) {
             this.movable.moveAxis('y', this.dimensions.y.min);
         }
-    };
+    }
 
-    Scroller.prototype.zoomOut = function zoomOut () {
-        var dimensions = this.dimensions;
+    zoomOut() {
+        let dimensions = this.dimensions;
         dimensions.refresh();
         this._scale(dimensions.fitScale);
         this.movable.moveTo(dimensions.centerCoordinates());
-    };
+    }
 
-    Scroller.prototype.enable = function enable () {
+    enable() {
         this.enabled = true;
-    };
+    }
 
-    Scroller.prototype.disable = function disable () {
+    disable() {
         this.enabled = false;
-    };
+    }
 
-    Scroller.prototype.scrollTo = function scrollTo (x, y) {
+    scrollTo(x, y) {
         if (this._native) {
             this.scrollElement.scrollLeft(abs(x));
             this.scrollElement.scrollTop(abs(y));
@@ -578,10 +550,10 @@ export var Scroller = (function (Observable) {
                 y: y
             });
         }
-    };
+    }
 
-    Scroller.prototype.animatedScrollTo = function animatedScrollTo (x, y, callback) {
-        var from, to;
+    animatedScrollTo(x, y, callback) {
+        let from, to;
         if (this._native) {
             this.scrollTo(x, y);
         } else {
@@ -597,10 +569,10 @@ export var Scroller = (function (Observable) {
             this.animatedScroller.setCallback(callback);
             this.animatedScroller.start();
         }
-    };
+    }
 
     // kept for API compatibility, not used
-    Scroller.prototype.pullHandled = function pullHandled () {
+    pullHandled() {
         // let that = this;
 
         // removeClass(that.refreshHint, SCROLLER_REFRESH_CLASS);
@@ -609,28 +581,28 @@ export var Scroller = (function (Observable) {
         // that.yinertia.onEnd();
         // that.xinertia.onEnd();
         // that.userEvents.cancel();
-    };
+    }
 
-    Scroller.prototype.destroy = function destroy () {
-        var element = this.element;
+    destroy() {
+        const element = this.element;
 
         off(element, 'wheel', this._wheelScrollHandler);
 
         if (this.userEvents) {
             this.userEvents.destroy();
         }
-    };
+    }
 
-    Scroller.prototype._scale = function _scale (scale) {
+    _scale(scale) {
         this.dimensions.rescale(scale);
         this.movable.scaleTo(scale);
-    };
+    }
 
-    Scroller.prototype._initPullToRefresh = function _initPullToRefresh () {
-    };
+    _initPullToRefresh() {
+    }
 
     // kept for API compatibility, not used
-    Scroller.prototype._dragEnd = function _dragEnd () {
+    _dragEnd() {
         // let that = this;
 
         // if (!that.pulled) {
@@ -646,10 +618,10 @@ export var Scroller = (function (Observable) {
 
         // that.yinertia.freeze(that.options.pullOffset / 2);
         // that.trigger('pull');
-    };
+    }
 
     // kept for API compatibility, not used
-    Scroller.prototype._paneChange = function _paneChange () {
+    _paneChange() {
         // let that = this;
         // if (that.movable.y / OUT_OF_BOUNDS_FRICTION > that.options.pullOffset) {
         //     if (!that.pulled) {
@@ -663,10 +635,10 @@ export var Scroller = (function (Observable) {
         //     that.refreshHint.removeClass(SCROLLER_RELEASE_CLASS);
         //     that.hintContainer.html(that.pullTemplate({}));
         // }
-    };
+    }
 
-    Scroller.prototype._initAxis = function _initAxis (axis) {
-        var that = this,
+    _initAxis(axis) {
+        let that = this,
             movable = that.movable,
             dimension = that.dimensions[axis],
             tapCapture = that.tapCapture,
@@ -697,7 +669,7 @@ export var Scroller = (function (Observable) {
             elastic: that.options.elastic,
             friction: that.options.friction || FRICTION,
             velocityMultiplier: that.options.velocityMultiplier || VELOCITY_MULTIPLIER,
-            end: function end() {
+            end() {
                 scrollBar.hide();
                 that.trigger('scrollEnd', {
                     axis: axis,
@@ -706,10 +678,8 @@ export var Scroller = (function (Observable) {
                 });
             }
         });
-    };
-
-    return Scroller;
-}(Observable));
+    }
+}
 
 setDefaultOptions(Scroller, {
     name: 'Scroller',
@@ -719,7 +689,7 @@ setDefaultOptions(Scroller, {
     elastic: true,
     useNative: false,
     mousewheelScrolling: true,
-    avoidScrolling: function avoidScrolling() {
+    avoidScrolling() {
         return false;
     },
     pullToRefresh: false,