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

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

@@ -3,8 +3,8 @@ import Axis from './axis';
 import AxisLabel from './axis-label';
 import Box from './box';
 
-import { BLACK, DEFAULT_PRECISION, COORD_PRECISION, X, Y } from '../common/constants';
-import { deepExtend, defined, limitValue, round, setDefaultOptions } from '../common';
+import { BLACK, DEFAULT_PRECISION, COORD_PRECISION } from '../common/constants';
+import { deepExtend, defined, limitValue, round, setDefaultOptions, valueOrDefault } from '../common';
 
 import autoMajorUnit from './utils/auto-major-unit';
 import autoAxisMin from './utils/auto-axis-min';
@@ -70,17 +70,13 @@ class NumericAxis extends Axis {
 
     getTickPositions(unit, skipUnit) {
         const options = this.options;
-        const { vertical, reverse } = options;
-        const lineBox = this.lineBox();
-        const lineSize = vertical ? lineBox.height() : lineBox.width();
+        const { axisDir, axisOrigin, lineBox, lineSize } = this.lineInfo();
         const range = options.max - options.min;
         const scale = lineSize / range;
         const step = unit * scale;
         const divisions = this.getDivisions(unit);
-        const dir = (vertical ? -1 : 1) * (reverse ? -1 : 1);
-        const startEdge = dir === 1 ? 1 : 2;
         const positions = [];
-        let pos = lineBox[(vertical ? Y : X) + startEdge];
+        let pos = lineBox[axisOrigin];
         let skipStep = 0;
 
         if (skipUnit) {
@@ -92,7 +88,7 @@ class NumericAxis extends Axis {
                 positions.push(round(pos, COORD_PRECISION));
             }
 
-            pos = pos + step * dir;
+            pos = pos + step * axisDir;
         }
 
         return positions;
@@ -108,79 +104,48 @@ class NumericAxis extends Axis {
 
     getSlot(a, b, limit = false) {
         const options = this.options;
-        const { vertical, reverse } = options;
-        const valueAxis = vertical ? Y : X;
-        const lineBox = this.lineBox();
-        const lineStart = lineBox[valueAxis + (reverse ? 2 : 1)];
-        const lineSize = vertical ? lineBox.height() : lineBox.width();
-        const dir = reverse ? -1 : 1;
-        const step = dir * (lineSize / (options.max - options.min));
-        const slotBox = new Box(lineBox.x1, lineBox.y1, lineBox.x1, lineBox.y1);
-
-        let start = a;
-        let end = b;
-
-        if (!defined(start)) {
-            start = end || 0;
-        }
+        const { axis, axisDir, lineBox, lineSize, lineStart } = this.lineInfo();
+        const step = axisDir * (lineSize / (options.max - options.min));
 
-        if (!defined(end)) {
-            end = start || 0;
-        }
+        let start = valueOrDefault(a, b || 0);
+        let end = valueOrDefault(b, a || 0);
 
         if (limit) {
-            start = Math.max(Math.min(start, options.max), options.min);
-            end = Math.max(Math.min(end, options.max), options.min);
+            start = limitValue(start, options.min, options.max);
+            end = limitValue(end, options.min, options.max);
         }
 
-        let p1, p2;
+        const p1 = Math.min(start, end) - options.min;
+        const p2 = Math.max(start, end) - options.min;
 
-        if (vertical) {
-            p1 = options.max - Math.max(start, end);
-            p2 = options.max - Math.min(start, end);
-        } else {
-            p1 = Math.min(start, end) - options.min;
-            p2 = Math.max(start, end) - options.min;
-        }
-
-        slotBox[valueAxis + 1] = limitCoordinate(lineStart + step * (reverse ? p2 : p1));
-        slotBox[valueAxis + 2] = limitCoordinate(lineStart + step * (reverse ? p1 : p2));
+        const slotBox = new Box(lineBox.x1, lineBox.y1, lineBox.x1, lineBox.y1);
+        slotBox[axis + 1] = limitCoordinate(lineStart + step * (axisDir > 0 ? p1 : p2));
+        slotBox[axis + 2] = limitCoordinate(lineStart + step * (axisDir > 0 ? p2 : p1));
 
         return slotBox;
     }
 
     getValue(point) {
         const options = this.options;
-        const { vertical, reverse } = options;
         const max = Number(options.max);
         const min = Number(options.min);
-        const valueAxis = vertical ? Y : X;
-        const lineBox = this.lineBox();
-        const lineStart = lineBox[valueAxis + (reverse ? 2 : 1)];
-        const lineSize = vertical ? lineBox.height() : lineBox.width();
-        const dir = reverse ? -1 : 1;
-        const offset = dir * (point[valueAxis] - lineStart);
-        const step = (max - min) / lineSize;
-        const valueOffset = offset * step;
-
-        if (offset < 0 || offset > lineSize) {
+        const offset = this.pointOffset(point);
+        const valueOffset = offset * (max - min);
+
+        if (offset < 0 || offset > 1) {
             return null;
         }
 
-        const value = vertical ?
-                max - valueOffset :
-                min + valueOffset;
-
+        const value = min + valueOffset;
         return round(value, DEFAULT_PRECISION);
     }
 
     translateRange(delta) {
         const options = this.options;
         const { vertical, reverse, max, min } = options;
-        const lineBox = this.lineBox();
-        const size = vertical ? lineBox.height() : lineBox.width();
+        const { lineSize } = this.lineInfo();
         const range = max - min;
-        const scale = size / range;
+        const scale = lineSize / range;
         let offset = round(delta / scale, DEFAULT_PRECISION);
 
         if ((vertical || reverse) && !(vertical && reverse )) {