@progress/kendo-charts 1.19.0 → 1.20.0-dev.202111081615

package/dist/es/chart/chart.js

@@ -22,12 +22,13 @@ import { ChartPane, ChartPlotArea, findAxisByName } from './api-elements';
 
 import { X, Y, VALUE, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_SERIES_OPACITY } from '../common/constants';
 import { addClass, Class, setDefaultOptions, deepExtend, defined, find, isObject, isFunction, elementSize, elementOffset,
-         elementScale, elementStyles, eventCoordinates, bindEvents, unbindEvents, mousewheelDelta, FontLoader, inArray, last, round, HashMap } from '../common';
+         elementScale, elementStyles, eventCoordinates, bindEvents, unbindEvents, mousewheelDelta, FontLoader, inArray, last, round,
+         HashMap, valueOrDefault } from '../common';
 
 import { dateComparer } from '../date-utils';
 
 import { DRAG_START, DRAG, DRAG_END, ZOOM_START, ZOOM, ZOOM_END, SELECT_START, SELECT, SELECT_END, PLOT_AREA_HOVER, PLOT_AREA_LEAVE,
-    RENDER, CATEGORY, PIE, DONUT, FUNNEL, COLUMN, MOUSEWHEEL, MOUSEWHEEL_DELAY, SHOW_TOOLTIP, SERIES_HOVER } from './constants';
+    RENDER, CATEGORY, PIE, DONUT, FUNNEL, COLUMN, MOUSEWHEEL, MOUSEWHEEL_DELAY, MOUSEWHEEL_ZOOM_RATE, SHOW_TOOLTIP, SERIES_HOVER } from './constants';
 
 import './animations';
 import './register-charts';
@@ -664,12 +665,13 @@ var Chart = (function (Class) {
                 this._gestureDistance = e.distance;
                 var args = { delta: scaleDelta, axisRanges: axisRanges(this._plotArea.axes), originalEvent: e };
                 if (this._zooming || !this.trigger(ZOOM_START, args)) {
+                    var coords = this._eventCoordinates(e);
 
                     if (!this._zooming) {
                         this._zooming = true;
                     }
 
-                    var ranges = args.axisRanges = mousewheelZoom.updateRanges(scaleDelta);
+                    var ranges = args.axisRanges = mousewheelZoom.updateRanges(scaleDelta, coords);
                     if (ranges && !this.trigger(ZOOM, args)) {
                         mousewheelZoom.zoom();
                     }
@@ -802,6 +804,12 @@ var Chart = (function (Class) {
         }
     };
 
+    Chart.prototype._mousewheelZoomRate = function _mousewheelZoomRate () {
+        var zoomable = this.options.zoomable;
+        var mousewheel = (zoomable || {}).mousewheel || {};
+        return valueOrDefault(mousewheel.rate, MOUSEWHEEL_ZOOM_RATE);
+    };
+
     Chart.prototype._mousewheel = function _mousewheel (e) {
         var this$1 = this;
 
@@ -828,7 +836,7 @@ var Chart = (function (Class) {
                     clearTimeout(this._mwTimeout);
                 }
 
-                args.axisRanges = mousewheelZoom.updateRanges(delta);
+                args.axisRanges = mousewheelZoom.updateRanges(delta, coords);
                 if (args.axisRanges && !this.trigger(ZOOM, args)) {
                     mousewheelZoom.zoom();
                 }
@@ -861,7 +869,7 @@ var Chart = (function (Class) {
                     var currentAxis = axes[i];
                     var axisName = currentAxis.options.name;
                     if (axisName) {
-                        ranges[axisName] = currentAxis.scaleRange(-totalDelta);
+                        ranges[axisName] = currentAxis.scaleRange(-totalDelta * this$1._mousewheelZoomRate(), coords);
                     }
                 }
 

package/dist/es/chart/constants.js

@@ -94,6 +94,7 @@ var OUTSIDE_END = "outsideEnd";
 
 var MOUSEWHEEL = "DOMMouseScroll mousewheel";
 var MOUSEWHEEL_DELAY = 150;
+var MOUSEWHEEL_ZOOM_RATE = 0.3;
 
 export {
     INITIAL_ANIMATION_DURATION, FADEIN,
@@ -115,7 +116,8 @@ export {
     LOGARITHMIC, DRAG, DRAG_START, DRAG_END, ZOOM_START, ZOOM, ZOOM_END,
     SELECT_START, SELECT, SELECT_END, PANE_RENDER, GAP,
     DONUT, INSIDE_END, INSIDE_BASE, OUTSIDE_END,
-    MOUSEWHEEL, MOUSEWHEEL_DELAY, SHOW_TOOLTIP, HIDE_TOOLTIP,
+    MOUSEWHEEL, MOUSEWHEEL_DELAY, MOUSEWHEEL_ZOOM_RATE,
+    SHOW_TOOLTIP, HIDE_TOOLTIP,
     EQUALLY_SPACED_SERIES, ABOVE, BELOW,
     HEATMAP
 };

package/dist/es/chart/pan-and-zoom/mousewheel-zoom.js

@@ -9,14 +9,18 @@ var MousewheelZoom = (function (Class) {
         Class.call(this);
 
         this.chart = chart;
-        this.options = deepExtend({}, this.options, options);
+        this.options = deepExtend({
+            rate: 0.3
+        }, this.options, options);
     }
 
     if ( Class ) MousewheelZoom.__proto__ = Class;
     MousewheelZoom.prototype = Object.create( Class && Class.prototype );
     MousewheelZoom.prototype.constructor = MousewheelZoom;
 
-    MousewheelZoom.prototype.updateRanges = function updateRanges (delta) {
+    MousewheelZoom.prototype.updateRanges = function updateRanges (delta, coords) {
+        var this$1 = this;
+
         var lock = (this.options.lock || "").toLowerCase();
         var axisRanges = [];
         var axes = this.chart._plotArea.axes;
@@ -26,7 +30,7 @@ var MousewheelZoom = (function (Class) {
             var vertical = axis.options.vertical;
 
             if (!(lock === X && !vertical) && !(lock === Y && vertical) && axis.zoomRange) {
-                var range = axis.zoomRange(-delta);
+                var range = axis.zoomRange(-delta * this$1.options.rate, coords);
 
                 if (range) {
                     axisRanges.push({
@@ -61,4 +65,4 @@ var MousewheelZoom = (function (Class) {
     return MousewheelZoom;
 }(Class));
 
-export default MousewheelZoom;
+export default MousewheelZoom;

package/dist/es/chart/selection.js

@@ -4,7 +4,7 @@ import { DateCategoryAxis, Point } from '../core';
 
 import { MOUSEWHEEL_DELAY, MOUSEWHEEL, SELECT_START, SELECT, SELECT_END } from './constants';
 
-import { LEFT, RIGHT, MIN_VALUE, MAX_VALUE } from '../common/constants';
+import { LEFT, RIGHT, MIN_VALUE, MAX_VALUE, X } from '../common/constants';
 import { addClass, Class, removeClass, deepExtend, elementStyles, eventElement, setDefaultOptions, limitValue, round, bindEvents, unbindEvents, mousewheelDelta, hasClasses } from '../common';
 import { parseDate } from '../date-utils';
 
@@ -564,6 +564,46 @@ var Selection = (function (Class) {
         }
     };
 
+    Selection.prototype.zoom = function zoom (delta, coords) {
+        var options = this.options;
+        var min = this._index(options.min);
+        var max = this._index(options.max);
+        var from = this._index(options.from);
+        var to = this._index(options.to);
+        var range = { from: from, to: to };
+        var oldRange = deepExtend({}, range);
+
+        var ref = this.categoryAxis.options;
+        var reverse = ref.reverse;
+        var origin = X + (reverse ? '2' : '1');
+        var lineBox = this.categoryAxis.lineBox();
+        var relative = Math.abs(lineBox[origin] - coords[X]);
+        var size = lineBox.width();
+        var position = round(relative / size, 2);
+        var minDelta = round(position * delta);
+        var maxDelta = round((1 - position) * delta);
+
+        if (this._state) {
+            range = this._state.range;
+        }
+
+        range.from = limitValue(
+            limitValue(from - minDelta, 0, to - 1),
+            min, max
+        );
+
+        range.to = limitValue(
+            limitValue(to + maxDelta, range.from + 1, max),
+            min,
+            max
+        );
+
+        if (range.from !== oldRange.from || range.to !== oldRange.to) {
+            this.set(range.from, range.to);
+            return true;
+        }
+    };
+
     Selection.prototype.trigger = function trigger (name, args) {
         return (this.observer || this.chart).trigger(name, args);
     };

package/dist/es/common/create-hash-set.js

@@ -80,9 +80,19 @@ prototypeAccessors$1.size.get = function () {
 Object.defineProperties( SetWrapper.prototype, prototypeAccessors$1 );
 
 // TODO: Drop LegacySet when removing support for IE10
+var supportsSet = function () {
+    var supported = false;
 
-export default function createHashSet(values) {
     if (typeof Set === 'function') {
+        var set = new Set([1]);
+        supported = set.has(1);
+    }
+
+    return supported;
+};
+
+export default function createHashSet(values) {
+    if (supportsSet()) {
         return new SetWrapper(values);
     }
 

package/dist/es/common/mousewheel-delta.js

@@ -1,16 +1,13 @@
-import { drawing } from '@progress/kendo-drawing';
-
 export default function mousewheelDelta(e) {
     var delta = 0;
 
     if (e.wheelDelta) {
         delta = -e.wheelDelta / 120;
-        delta = delta > 0 ? Math.ceil(delta) : Math.floor(delta);
+    } else if (e.detail) {
+        delta = e.detail / 3;
     }
 
-    if (e.detail) {
-        delta = drawing.util.round(e.detail / 3);
-    }
+    delta = delta > 0 ? Math.ceil(delta) : Math.floor(delta);
 
     return delta;
-}
+}

package/dist/es/core/axis.js

@@ -860,6 +860,41 @@ var Axis = (function (ChartElement) {
         };
     };
 
+    Axis.prototype.lineInfo = function lineInfo () {
+        var ref = this.options;
+        var vertical = ref.vertical;
+        var reverse = ref.reverse;
+        var lineBox = this.lineBox();
+        var lineSize = vertical ? lineBox.height() : lineBox.width();
+        var axis = vertical ? Y : X;
+        var axisDir = (vertical ? -1 : 1) * (reverse ? -1 : 1);
+        var startEdge = axisDir === 1 ? 1 : 2;
+        var axisOrigin = axis + startEdge.toString();
+        var lineStart = lineBox[axisOrigin];
+
+        return {
+            axis: axis,
+            axisOrigin: axisOrigin,
+            axisDir: axisDir,
+            lineBox: lineBox,
+            lineSize: lineSize,
+            lineStart: lineStart
+        };
+    };
+
+    Axis.prototype.pointOffset = function pointOffset (point) {
+        var ref = this.lineInfo();
+        var axis = ref.axis;
+        var axisDir = ref.axisDir;
+        var axisOrigin = ref.axisOrigin;
+        var lineBox = ref.lineBox;
+        var lineSize = ref.lineSize;
+        var relative = axisDir > 0 ? point[axis] - lineBox[axisOrigin] : lineBox[axisOrigin] - point[axis];
+        var offset = relative / lineSize;
+
+        return offset;
+    };
+
     Axis.prototype.labelsBetweenTicks = function labelsBetweenTicks () {
         return !this.options.justified;
     };

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

@@ -6,6 +6,7 @@ import { defined, isNumber, last, limitValue, round, setDefaultOptions, valueOrD
 import { dateEquals } from '../date-utils';
 
 var MIN_CATEGORY_POINTS_RANGE = 0.01;
+var MIN_CATEGORY_RANGE = 0.1;
 
 function indexOf(value, arr) {
     if (value instanceof Date) {
@@ -406,29 +407,34 @@ var CategoryAxis = (function (Axis) {
         };
     };
 
-    CategoryAxis.prototype.zoomRange = function zoomRange (rate) {
+    CategoryAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
+        var position = Math.abs(this.pointOffset(cursor));
         var rangeIndices = this.totalRangeIndices();
-        var ref = this.totalRange();
-        var totalMin = ref.min;
-        var totalMax = ref.max;
-        var min = limitValue(rangeIndices.min + rate, totalMin, totalMax);
-        var max = limitValue(rangeIndices.max - rate, totalMin, totalMax);
-
-        if (max - min > 0) {
-            return {
-                min: min,
-                max: max
-            };
+        var delta = (rangeIndices.max - rangeIndices.min) * Math.min(1, scale);
+        var minDelta = position * delta;
+        var maxDelta = (1 - position) * delta;
+        var min = rangeIndices.min + minDelta;
+        var max = rangeIndices.max - maxDelta;
+
+        if (max - min < MIN_CATEGORY_RANGE) {
+            max = min + MIN_CATEGORY_RANGE;
         }
+
+        return {
+            min: min,
+            max: max
+        };
     };
 
-    CategoryAxis.prototype.scaleRange = function scaleRange (scale) {
-        var range = this.options.categories.length;
-        var delta = scale * range;
+    CategoryAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
+        var ref = this.totalRange();
+        var totalMin = ref.min;
+        var totalMax = ref.max;
+        var range = this.scaleRange(scale, cursor);
 
         return {
-            min: -delta,
-            max: range + delta
+            min: limitValue(range.min, totalMin, totalMax),
+            max: limitValue(range.max, totalMin, totalMax)
         };
     };
 

package/dist/es/core/date-category-axis.js

@@ -471,31 +471,6 @@ var DateCategoryAxis = (function (CategoryAxis) {
         return range;
     };
 
-    DateCategoryAxis.prototype.scaleRange = function scaleRange (delta) {
-        var rounds = Math.abs(delta);
-        var result = this.range();
-        var from = result.min;
-        var to = result.max;
-
-        if (from && to) {
-            while (rounds--) {
-                var range = dateDiff(from, to);
-                var step = Math.round(range * 0.1);
-                if (delta < 0) {
-                    from = addTicks(from, step);
-                    to = addTicks(to, -step);
-                } else {
-                    from = addTicks(from, -step);
-                    to = addTicks(to, step);
-                }
-            }
-
-            result = { min: from, max: to };
-        }
-
-        return result;
-    };
-
     DateCategoryAxis.prototype.labelsRange = function labelsRange () {
         return {
             min: this.options.labels.skip,
@@ -556,9 +531,9 @@ var DateCategoryAxis = (function (CategoryAxis) {
         };
     };
 
-    DateCategoryAxis.prototype.zoomRange = function zoomRange (delta) {
+    DateCategoryAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
         if (this.isEmpty()) {
-            return null;
+            return {};
         }
 
         var options = this.options;
@@ -567,12 +542,16 @@ var DateCategoryAxis = (function (CategoryAxis) {
         var ref = this.dataRange.displayRange();
         var rangeMin = ref.min;
         var rangeMax = ref.max;
+
+        var position = Math.abs(this.pointOffset(cursor));
+        var delta = (rangeMax - rangeMin) * scale;
+        var minDelta = Math.round(position * delta);
+        var maxDelta = Math.round((1 - position) * delta);
+
         var ref$1 = this.dataRange.options;
-        var weekStartDay = ref$1.weekStartDay;
         var baseUnit = ref$1.baseUnit;
-        var baseUnitStep = ref$1.baseUnitStep;
-        var min = addDuration(rangeMin, delta * baseUnitStep, baseUnit, weekStartDay);
-        var max = addDuration(rangeMax, -delta * baseUnitStep, baseUnit, weekStartDay);
+        var min = new Date(rangeMin.getTime() + minDelta);
+        var max = new Date(rangeMax.getTime() - maxDelta);
 
         if (fit) {
             var autoBaseUnitSteps = options.autoBaseUnitSteps;
@@ -615,13 +594,6 @@ var DateCategoryAxis = (function (CategoryAxis) {
             }
         }
 
-        if (min < totalLimits.min) {
-            min = totalLimits.min;
-        }
-        if (max > totalLimits.max) {
-            max = totalLimits.max;
-        }
-
         if (min && max && dateDiff(max, min) > 0) {
             return {
                 min: min,
@@ -632,6 +604,22 @@ var DateCategoryAxis = (function (CategoryAxis) {
         }
     };
 
+    DateCategoryAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
+        var totalLimits = this.dataRange.total();
+        var range = this.scaleRange(scale, cursor);
+
+        if (range) {
+            if (range.min < totalLimits.min) {
+                range.min = totalLimits.min;
+            }
+            if (range.max > totalLimits.max) {
+                range.max = totalLimits.max;
+            }
+        }
+
+        return range;
+    };
+
     DateCategoryAxis.prototype.range = function range () {
         return this.dataRange.displayRange();
     };

package/dist/es/core/date-value-axis.js

@@ -12,6 +12,8 @@ import ceil from './utils/ceil';
 import { toDate, toTime, floorDate, ceilDate, duration, addDuration, addTicks, dateDiff, absoluteDateDiff, dateComparer, parseDate, parseDates, firstDay } from '../date-utils';
 import { HOURS, DAYS, WEEKS, MONTHS, YEARS, TIME_PER_DAY, TIME_PER_WEEK, TIME_PER_MONTH, TIME_PER_YEAR, TIME_PER_UNIT } from '../date-utils/constants';
 
+var MIN_VALUE_RANGE = 1000;
+
 var DateValueAxis = (function (Axis) {
     function DateValueAxis(seriesMin, seriesMax, axisOptions, chartService) {
         var min = toDate(seriesMin);
@@ -124,23 +126,23 @@ var DateValueAxis = (function (Axis) {
         return new AxisLabel(date, text, index, null, labelOptions);
     };
 
-    DateValueAxis.prototype.translateRange = function translateRange (delta, exact) {
+    DateValueAxis.prototype.translateRange = function translateRange (delta) {
         var options = this.options;
-        var baseUnit = options.baseUnit;
-        var weekStartDay = options.weekStartDay || 0;
         var lineBox = this.lineBox();
-        var size = options.vertical ? lineBox.height() : lineBox.width();
+        var vertical = options.vertical;
+        var reverse = options.reverse;
+        var size = vertical ? lineBox.height() : lineBox.width();
         var range = this.range();
         var scale = size / dateDiff(range.max, range.min);
-        var offset = round(delta / scale, DEFAULT_PRECISION) * (options.reverse ? -1 : 1);
-        var from = addTicks(options.min, offset);
-        var to = addTicks(options.max, offset);
 
-        if (!exact) {
-            from = addDuration(from, 0, baseUnit, weekStartDay);
-            to = addDuration(to, 0, baseUnit, weekStartDay);
+        var offset = round(delta / scale, DEFAULT_PRECISION);
+        if ((vertical || reverse) && !(vertical && reverse )) {
+            offset = -offset;
         }
 
+        var from = addTicks(options.min, offset);
+        var to = addTicks(options.max, offset);
+
         return {
             min: from,
             max: to,
@@ -148,27 +150,6 @@ var DateValueAxis = (function (Axis) {
         };
     };
 
-    DateValueAxis.prototype.scaleRange = function scaleRange (delta) {
-        var ref = this.options;
-        var from = ref.min;
-        var to = ref.max;
-        var rounds = Math.abs(delta);
-
-        while (rounds--) {
-            var range = dateDiff(from, to);
-            var step = Math.round(range * 0.1);
-            if (delta < 0) {
-                from = addTicks(from, step);
-                to = addTicks(to, -step);
-            } else {
-                from = addTicks(from, -step);
-                to = addTicks(to, step);
-            }
-        }
-
-        return { min: from, max: to };
-    };
-
     DateValueAxis.prototype.shouldRenderNote = function shouldRenderNote (value) {
         var range = this.range();
 
@@ -199,8 +180,26 @@ var DateValueAxis = (function (Axis) {
         };
     };
 
-    DateValueAxis.prototype.zoomRange = function zoomRange (delta) {
-        var range = this.scaleRange(delta);
+    DateValueAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
+        var position = Math.abs(this.pointOffset(cursor));
+        var delta = (this.options.max - this.options.min) * Math.min(1, scale);
+        var minDelta = position * delta;
+        var maxDelta = (1 - position) * delta;
+        var min = toDate(toTime(this.options.min) + minDelta);
+        var max = toDate(toTime(this.options.max) - maxDelta);
+
+        if (max - min < MIN_VALUE_RANGE) {
+            max = toDate(toTime(min) + MIN_VALUE_RANGE);
+        }
+
+        return {
+            min: min,
+            max: max
+        };
+    };
+
+    DateValueAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
+        var range = this.scaleRange(scale, cursor);
         var min = toDate(limitValue(toTime(range.min), this.totalMin, this.totalMax));
         var max = toDate(limitValue(toTime(range.max), this.totalMin, this.totalMax));
 

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

@@ -11,6 +11,7 @@ import { DEFAULT_PRECISION, BLACK, X, Y } from '../common/constants';
 import { deepExtend, defined, inArray, limitValue, round, setDefaultOptions } from '../common';
 
 var DEFAULT_MAJOR_UNIT = 10;
+var MIN_VALUE_RANGE = 1e-6;
 
 var LogarithmicAxis = (function (Axis) {
     function LogarithmicAxis(seriesMin, seriesMax, options, chartService) {
@@ -140,16 +141,6 @@ var LogarithmicAxis = (function (Axis) {
         return { min: options.min, max: options.max };
     };
 
-    LogarithmicAxis.prototype.scaleRange = function scaleRange (delta) {
-        var base = this.options.majorUnit;
-        var offset = -delta;
-
-        return {
-            min: Math.pow(base, this.logMin - offset),
-            max: Math.pow(base, this.logMax + offset)
-        };
-    };
-
     LogarithmicAxis.prototype.translateRange = function translateRange (delta) {
         var ref = this;
         var options = ref.options;
@@ -333,24 +324,36 @@ var LogarithmicAxis = (function (Axis) {
         };
     };
 
-    LogarithmicAxis.prototype.zoomRange = function zoomRange (delta) {
+    LogarithmicAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
+        var ref = this.options;
+        var base = ref.majorUnit;
+        var logMin = log(this.options.min, base);
+        var logMax = log(this.options.max, base);
+        var position = Math.abs(this.pointOffset(cursor));
+        var delta = (logMax - logMin) * Math.min(1, scale);
+        var min = Math.pow(base, logMin + position * delta);
+        var max = Math.pow(base, logMax - (1 - position) * delta);
+
+        if (max - min < MIN_VALUE_RANGE) {
+            max = min + MIN_VALUE_RANGE;
+        }
+
+        return {
+            min: min,
+            max: max
+        };
+    };
+
+    LogarithmicAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
+        var range = this.scaleRange(scale, cursor);
         var ref = this;
-        var options = ref.options;
         var totalMin = ref.totalMin;
         var totalMax = ref.totalMax;
-        var newRange = this.scaleRange(delta);
-        var min = limitValue(newRange.min, totalMin, totalMax);
-        var max = limitValue(newRange.max, totalMin, totalMax);
-        var base = options.majorUnit;
-        var acceptOptionsRange = max > min && options.min && options.max && (round(log(options.max, base) - log(options.min, base), DEFAULT_PRECISION) < 1);
-        var acceptNewRange = !(options.min === totalMin && options.max === totalMax) && round(log(max, base) - log(min, base), DEFAULT_PRECISION) >= 1;
-
-        if (acceptOptionsRange || acceptNewRange) {
-            return {
-                min: min,
-                max: max
-            };
-        }
+
+        return {
+            min: limitValue(range.min, totalMin, totalMax),
+            max: limitValue(range.max, totalMin, totalMax)
+        };
     };
 
     LogarithmicAxis.prototype._minorIntervalOptions = function _minorIntervalOptions (power) {
@@ -445,8 +448,8 @@ function throwNegativeValuesError() {
     throw new Error("Non positive values cannot be used for a logarithmic axis");
 }
 
-function log(y, x) {
-    return Math.log(y) / Math.log(x);
+function log(x, base) {
+    return Math.log(x) / Math.log(base);
 }
 
 setDefaultOptions(LogarithmicAxis, {

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

@@ -205,16 +205,6 @@ var NumericAxis = (function (Axis) {
         };
     };
 
-    NumericAxis.prototype.scaleRange = function scaleRange (delta) {
-        var options = this.options;
-        var offset = -delta * options.majorUnit;
-
-        return {
-            min: options.min - offset,
-            max: options.max + offset
-        };
-    };
-
     NumericAxis.prototype.labelsCount = function labelsCount () {
         return this.getDivisions(this.options.majorUnit);
     };
@@ -251,20 +241,34 @@ var NumericAxis = (function (Axis) {
         }
     };
 
-    NumericAxis.prototype.zoomRange = function zoomRange (delta) {
+    NumericAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
+        var position = Math.abs(this.pointOffset(cursor));
+        var delta = (this.options.max - this.options.min) * Math.min(1, scale);
+        var minDelta = position * delta;
+        var maxDelta = (1 - position) * delta;
+        var min = this.options.min + minDelta;
+        var max = this.options.max - maxDelta;
+
+        if (max - min < MIN_VALUE_RANGE) {
+            max = min + MIN_VALUE_RANGE;
+        }
+
+        return {
+            min: min,
+            max: max
+        };
+    };
+
+    NumericAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
         var ref = this;
         var totalMin = ref.totalMin;
         var totalMax = ref.totalMax;
-        var newRange = this.scaleRange(delta);
-        var min = limitValue(newRange.min, totalMin, totalMax);
-        var max = limitValue(newRange.max, totalMin, totalMax);
+        var range = this.scaleRange(scale, cursor);
 
-        if (this.isValidRange(min, max)) {
-            return {
-                min: min,
-                max: max
-            };
-        }
+        return {
+            min: limitValue(range.min, totalMin, totalMax),
+            max: limitValue(range.max, totalMin, totalMax)
+        };
     };
 
     NumericAxis.prototype.isValidRange = function isValidRange (min, max) {

package/dist/es/main.js

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