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

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

@@ -6,6 +6,7 @@ import { defined, isNumber, last, limitValue, round, setDefaultOptions, valueOrD
 import { dateEquals } from '../date-utils';
 
 const MIN_CATEGORY_POINTS_RANGE = 0.01;
+const MIN_CATEGORY_RANGE = 0.1;
 
 function indexOf(value, arr) {
     if (value instanceof Date) {
@@ -375,27 +376,32 @@ class CategoryAxis extends Axis {
         };
     }
 
-    zoomRange(rate) {
+    scaleRange(scale, cursor) {
+        const position = Math.abs(this.pointOffset(cursor));
         const rangeIndices = this.totalRangeIndices();
-        const { min: totalMin, max: totalMax } = this.totalRange();
-        const min = limitValue(rangeIndices.min + rate, totalMin, totalMax);
-        const max = limitValue(rangeIndices.max - rate, totalMin, totalMax);
-
-        if (max - min > 0) {
-            return {
-                min: min,
-                max: max
-            };
+        const delta = (rangeIndices.max - rangeIndices.min) * Math.min(1, scale);
+        const minDelta = position * delta;
+        const maxDelta = (1 - position) * delta;
+        const min = rangeIndices.min + minDelta;
+        let max = rangeIndices.max - maxDelta;
+
+        if (max - min < MIN_CATEGORY_RANGE) {
+            max = min + MIN_CATEGORY_RANGE;
         }
+
+        return {
+            min: min,
+            max: max
+        };
     }
 
-    scaleRange(scale) {
-        const range = this.options.categories.length;
-        const delta = scale * range;
+    zoomRange(scale, cursor) {
+        const { min: totalMin, max: totalMax } = this.totalRange();
+        const 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/es2015/core/date-category-axis.js

@@ -459,30 +459,6 @@ class DateCategoryAxis extends CategoryAxis {
         return range;
     }
 
-    scaleRange(delta) {
-        let rounds = Math.abs(delta);
-        let result = this.range();
-        let { min: from, max: to } = result;
-
-        if (from && to) {
-            while (rounds--) {
-                const range = dateDiff(from, to);
-                const 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;
-    }
-
     labelsRange() {
         return {
             min: this.options.labels.skip,
@@ -541,18 +517,24 @@ class DateCategoryAxis extends CategoryAxis {
         };
     }
 
-    zoomRange(delta) {
+    scaleRange(scale, cursor) {
         if (this.isEmpty()) {
-            return null;
+            return {};
         }
 
         const options = this.options;
         const fit = options.userSetBaseUnit === FIT;
         const totalLimits = this.dataRange.total();
         const { min: rangeMin, max: rangeMax } = this.dataRange.displayRange();
-        let { weekStartDay, baseUnit, baseUnitStep } = this.dataRange.options;
-        let min = addDuration(rangeMin, delta * baseUnitStep, baseUnit, weekStartDay);
-        let max = addDuration(rangeMax, -delta * baseUnitStep, baseUnit, weekStartDay);
+
+        const position = Math.abs(this.pointOffset(cursor));
+        const delta = (rangeMax - rangeMin) * scale;
+        const minDelta = Math.round(position * delta);
+        const maxDelta = Math.round((1 - position) * delta);
+
+        let { baseUnit } = this.dataRange.options;
+        let min = new Date(rangeMin.getTime() + minDelta);
+        let max = new Date(rangeMax.getTime() - maxDelta);
 
         if (fit) {
             const { autoBaseUnitSteps, maxDateGroups } = options;
@@ -594,13 +576,6 @@ class DateCategoryAxis extends 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,
@@ -611,6 +586,22 @@ class DateCategoryAxis extends CategoryAxis {
         }
     }
 
+    zoomRange(scale, cursor) {
+        const totalLimits = this.dataRange.total();
+        const 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;
+    }
+
     range() {
         return this.dataRange.displayRange();
     }

package/dist/es2015/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';
 
+const MIN_VALUE_RANGE = 1000;
+
 class DateValueAxis extends Axis {
     constructor(seriesMin, seriesMax, axisOptions, chartService) {
         const min = toDate(seriesMin);
@@ -120,23 +122,22 @@ class DateValueAxis extends Axis {
         return new AxisLabel(date, text, index, null, labelOptions);
     }
 
-    translateRange(delta, exact) {
+    translateRange(delta) {
         const options = this.options;
-        const baseUnit = options.baseUnit;
-        const weekStartDay = options.weekStartDay || 0;
         const lineBox = this.lineBox();
-        const size = options.vertical ? lineBox.height() : lineBox.width();
+        const { vertical, reverse } = options;
+        const size = vertical ? lineBox.height() : lineBox.width();
         const range = this.range();
         const scale = size / dateDiff(range.max, range.min);
-        const offset = round(delta / scale, DEFAULT_PRECISION) * (options.reverse ? -1 : 1);
-        let from = addTicks(options.min, offset);
-        let to = addTicks(options.max, offset);
 
-        if (!exact) {
-            from = addDuration(from, 0, baseUnit, weekStartDay);
-            to = addDuration(to, 0, baseUnit, weekStartDay);
+        let offset = round(delta / scale, DEFAULT_PRECISION);
+        if ((vertical || reverse) && !(vertical && reverse )) {
+            offset = -offset;
         }
 
+        let from = addTicks(options.min, offset);
+        let to = addTicks(options.max, offset);
+
         return {
             min: from,
             max: to,
@@ -144,25 +145,6 @@ class DateValueAxis extends Axis {
         };
     }
 
-    scaleRange(delta) {
-        let { min: from, max: to } = this.options;
-        let rounds = Math.abs(delta);
-
-        while (rounds--) {
-            const range = dateDiff(from, to);
-            const 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 };
-    }
-
     shouldRenderNote(value) {
         const range = this.range();
 
@@ -193,16 +175,34 @@ class DateValueAxis extends Axis {
         };
     }
 
-    zoomRange(delta) {
-        const range = this.scaleRange(delta);
-        const min = toDate(limitValue(toTime(range.min), this.totalMin, this.totalMax));
-        const max = toDate(limitValue(toTime(range.max), this.totalMin, this.totalMax));
+    scaleRange(scale, cursor) {
+        const position = Math.abs(this.pointOffset(cursor));
+        const delta = (this.options.max - this.options.min) * Math.min(1, scale);
+        const minDelta = position * delta;
+        const maxDelta = (1 - position) * delta;
+        const min = toDate(toTime(this.options.min) + minDelta);
+        let 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
         };
     }
+
+    zoomRange(scale, cursor) {
+        const range = this.scaleRange(scale, cursor);
+        const min = toDate(limitValue(toTime(range.min), this.totalMin, this.totalMax));
+        const max = toDate(limitValue(toTime(range.max), this.totalMin, this.totalMax));
+
+        return {
+            min,
+            max
+        };
+    }
 }
 
 function timeUnits(delta) {

package/dist/es2015/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';
 
 const DEFAULT_MAJOR_UNIT = 10;
+const MIN_VALUE_RANGE = 1e-6;
 
 class LogarithmicAxis extends Axis {
     constructor(seriesMin, seriesMax, options, chartService) {
@@ -126,16 +127,6 @@ class LogarithmicAxis extends Axis {
         return { min: options.min, max: options.max };
     }
 
-    scaleRange(delta) {
-        const base = this.options.majorUnit;
-        const offset = -delta;
-
-        return {
-            min: Math.pow(base, this.logMin - offset),
-            max: Math.pow(base, this.logMax + offset)
-        };
-    }
-
     translateRange(delta) {
         const { options, logMin, logMax } = this;
         const { reverse, vertical, majorUnit: base } = options;
@@ -296,21 +287,33 @@ class LogarithmicAxis extends Axis {
         };
     }
 
-    zoomRange(delta) {
-        const { options, totalMin, totalMax } = this;
-        const newRange = this.scaleRange(delta);
-        const min = limitValue(newRange.min, totalMin, totalMax);
-        const max = limitValue(newRange.max, totalMin, totalMax);
-        const base = options.majorUnit;
-        const acceptOptionsRange = max > min && options.min && options.max && (round(log(options.max, base) - log(options.min, base), DEFAULT_PRECISION) < 1);
-        const 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
-            };
+    scaleRange(scale, cursor) {
+        const { majorUnit: base } = this.options;
+        const logMin = log(this.options.min, base);
+        const logMax = log(this.options.max, base);
+        const position = Math.abs(this.pointOffset(cursor));
+        const delta = (logMax - logMin) * Math.min(1, scale);
+        const min = Math.pow(base, logMin + position * delta);
+        let max = Math.pow(base, logMax - (1 - position) * delta);
+
+        if (max - min < MIN_VALUE_RANGE) {
+            max = min + MIN_VALUE_RANGE;
         }
+
+        return {
+            min: min,
+            max: max
+        };
+    }
+
+    zoomRange(scale, cursor) {
+        const range = this.scaleRange(scale, cursor);
+        const { totalMin, totalMax } = this;
+
+        return {
+            min: limitValue(range.min, totalMin, totalMax),
+            max: limitValue(range.max, totalMin, totalMax)
+        };
     }
 
     _minorIntervalOptions(power) {
@@ -398,8 +401,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/es2015/core/numeric-axis.js

@@ -194,16 +194,6 @@ class NumericAxis extends Axis {
         };
     }
 
-    scaleRange(delta) {
-        const options = this.options;
-        const offset = -delta * options.majorUnit;
-
-        return {
-            min: options.min - offset,
-            max: options.max + offset
-        };
-    }
-
     labelsCount() {
         return this.getDivisions(this.options.majorUnit);
     }
@@ -240,18 +230,32 @@ class NumericAxis extends Axis {
         }
     }
 
-    zoomRange(delta) {
-        const { totalMin, totalMax } = this;
-        const newRange = this.scaleRange(delta);
-        const min = limitValue(newRange.min, totalMin, totalMax);
-        const max = limitValue(newRange.max, totalMin, totalMax);
+    scaleRange(scale, cursor) {
+        const position = Math.abs(this.pointOffset(cursor));
+        const delta = (this.options.max - this.options.min) * Math.min(1, scale);
+        const minDelta = position * delta;
+        const maxDelta = (1 - position) * delta;
+        const min = this.options.min + minDelta;
+        let max = this.options.max - maxDelta;
 
-        if (this.isValidRange(min, max)) {
-            return {
-                min: min,
-                max: max
-            };
+        if (max - min < MIN_VALUE_RANGE) {
+            max = min + MIN_VALUE_RANGE;
         }
+
+        return {
+            min: min,
+            max: max
+        };
+    }
+
+    zoomRange(scale, cursor) {
+        const { totalMin, totalMax } = this;
+        const range = this.scaleRange(scale, cursor);
+
+        return {
+            min: limitValue(range.min, totalMin, totalMax),
+            max: limitValue(range.max, totalMin, totalMax)
+        };
     }
 
     isValidRange(min, max) {

package/dist/es2015/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';

package/dist/es2015/qrcode/encodings/data-modes/alpha-numeric-data-mode.js

@@ -0,0 +1,91 @@
+import { QRDataMode } from './qr-data-mode';
+import { extend } from '../../utils';
+import {
+    toBitsString,
+    splitInto
+} from '../../utils';
+
+export class AlphaNumericQRDataMode extends QRDataMode {
+    initProperties() {
+        super.initProperties();
+
+        extend(this, {
+            characters: {
+                "0": 0,
+                "1": 1,
+                "2": 2,
+                "3": 3,
+                "4": 4,
+                "5": 5,
+                "6": 6,
+                "7": 7,
+                "8": 8,
+                "9": 9,
+                "A": 10,
+                "B": 11,
+                "C": 12,
+                "D": 13,
+                "E": 14,
+                "F": 15,
+                "G": 16,
+                "H": 17,
+                "I": 18,
+                "J": 19,
+                "K": 20,
+                "L": 21,
+                "M": 22,
+                "N": 23,
+                "O": 24,
+                "P": 25,
+                "Q": 26,
+                "R": 27,
+                "S": 28,
+                "T": 29,
+                "U": 30,
+                "V": 31,
+                "W": 32,
+                "X": 33,
+                "Y": 34,
+                "Z": 35,
+                " ": 36,
+                "$": 37,
+                "%": 38,
+                "*": 39,
+                "+": 40,
+                "-": 41,
+                ".": 42,
+                "/": 43,
+                ":": 44
+            },
+            bitsInCharacterCount: [9, 11, 13],
+            modeIndicator: "0010"
+        });
+    }
+
+    getValue(character) {
+        return this.characters[character];
+    }
+
+    encode(str, version) {
+        let
+            parts = splitInto(str, 2),
+            result = this.getModeCountString(str.length, version),
+            value;
+        let i;
+
+        for (i = 0; i < parts.length - 1; i++) {
+            value = 45 * this.getValue(parts[i].charAt(0)) + this.getValue(parts[i].charAt(1));
+            result += toBitsString(value, 11);
+        }
+
+        value = parts[i].length === 2 ?
+            45 * this.getValue(parts[i].charAt(0)) + this.getValue(parts[i].charAt(1)) :
+            this.getValue(parts[i].charAt(0));
+
+        return result + toBitsString(value, 1 + 5 * parts[i].length);
+    }
+
+    getStringBitsLength(inputLength, version) {
+        return 4 + this.getBitsCharacterCount(version) + 11 * Math.floor(inputLength / 2) + 6 * (inputLength % 2);
+    }
+}

package/dist/es2015/qrcode/encodings/data-modes/byte-data-mode.js

@@ -0,0 +1,41 @@
+import { QRDataMode } from './qr-data-mode';
+import { extend } from '../../utils';
+import {
+    toBitsString
+} from '../../utils';
+
+export class ByteQRDataMode extends QRDataMode {
+    initProperties() {
+        super.initProperties();
+
+        extend(this, {
+            bitsInCharacterCount: [8, 16, 16],
+            modeIndicator: "0100"
+        });
+    }
+
+    getValue(character) {
+        let code = character.charCodeAt(0);
+
+        if (code <= 127 || (160 <= code && code <= 255)) {
+            return code;
+        }
+
+        throw new Error("Unsupported character: " + character);
+    }
+
+    encode(str, version) {
+        let mode = this,
+            result = mode.getModeCountString(str.length, version);
+
+        for (let i = 0; i < str.length; i++) {
+            result += toBitsString(mode.getValue(str.charAt(i)), 8);
+        }
+
+        return result;
+    }
+
+    getStringBitsLength(inputLength, version) {
+        return 4 + this.getBitsCharacterCount(version) + 8 * inputLength;
+    }
+}

package/dist/es2015/qrcode/encodings/data-modes/data-mode-instances.js

@@ -0,0 +1,13 @@
+import { NumericQRDataMode } from './numeric-data-mode';
+import { AlphaNumericQRDataMode } from './alpha-numeric-data-mode';
+import { ByteQRDataMode } from './byte-data-mode';
+
+const NUMERIC = "numeric";
+const ALPHA_NUMERIC = "alphanumeric";
+const BYTE = "byte";
+
+export let DataModeInstances = {
+    [NUMERIC]: new NumericQRDataMode(),
+    [ALPHA_NUMERIC]: new AlphaNumericQRDataMode(),
+    [BYTE]: new ByteQRDataMode()
+};

package/dist/es2015/qrcode/encodings/data-modes/numeric-data-mode.js

@@ -0,0 +1,39 @@
+import { QRDataMode } from './qr-data-mode';
+import { extend } from '../../utils';
+import {
+    toBitsString,
+    splitInto
+} from '../../utils';
+
+export class NumericQRDataMode extends QRDataMode {
+    initProperties() {
+        super.initProperties();
+
+        extend(this, {
+            bitsInCharacterCount: [10, 12, 14],
+            modeIndicator: "0001"
+        });
+    }
+
+    getValue(character) {
+        return parseInt(character, 10);
+    }
+
+    encode(str, version) {
+        let mode = this,
+            parts = splitInto(str, 3),
+            result = mode.getModeCountString(str.length, version);
+        let i;
+
+        for (i = 0; i < parts.length - 1; i++) {
+            result += toBitsString(parts[i], 10);
+        }
+
+        return result + toBitsString(parts[i], 1 + 3 * parts[i].length);
+    }
+
+    getStringBitsLength(inputLength, version) {
+        let mod3 = inputLength % 3;
+        return 4 + this.getBitsCharacterCount(version) + 10 * Math.floor(inputLength / 3) + 3 * mod3 + (mod3 === 0 ? 0 : 1);
+    }
+}

package/dist/es2015/qrcode/encodings/data-modes/qr-data-mode.js

@@ -0,0 +1,44 @@
+import { Class } from '../../../common';
+import { extend } from '../../utils';
+import {
+    toBitsString
+} from '../../utils';
+
+export class QRDataMode extends Class {
+    constructor() {
+        super();
+
+        this.initProperties();
+    }
+
+    initProperties() {
+        extend(this, {
+            modeIndicator: "",
+            bitsInCharacterCount: []
+        });
+    }
+
+    getVersionIndex(version) {
+        if (version < 10) {
+            return 0;
+        } else if (version > 26) {
+            return 2;
+        }
+
+        return 1;
+    }
+
+    getBitsCharacterCount(version) {
+        return this.bitsInCharacterCount[this.getVersionIndex(version || 40)];
+    }
+
+    getModeCountString(length, version) {
+        return this.modeIndicator + toBitsString(length, this.getBitsCharacterCount(version));
+    }
+
+    encode() { }
+
+    getStringBitsLength() { }
+
+    getValue() { }
+}

package/dist/es2015/qrcode/encodings/encoders/iso-encoder.js

@@ -0,0 +1,19 @@
+import { Class } from '../../../common';
+import { EncodingResult } from '../encoding-result';
+import {
+    getModes,
+    getVersion,
+    getDataCodewordsCount,
+    getDataString
+} from '../encoding';
+
+export class IsoEncoder extends Class {
+    getEncodingResult(inputString, errorCorrectionLevel) {
+        let modes = getModes(inputString),
+            dataCodewordsCount = getDataCodewordsCount(modes),
+            version = getVersion(dataCodewordsCount, errorCorrectionLevel),
+            dataString = getDataString(modes, version);
+
+        return new EncodingResult(dataString, version);
+    }
+}