@progress/kendo-charts 1.19.1 → 1.20.0-dev.202111121622

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;
-
-        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;
-        }
+        const p1 = Math.min(start, end) - options.min;
+        const 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 )) {
@@ -194,16 +159,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 +195,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);
+    }
+}

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

@@ -0,0 +1,83 @@
+import { Class } from '../../../common';
+import { EncodingResult } from '../encoding-result';
+import { DataModeInstances } from '../data-modes/data-mode-instances';
+import { extend } from '../../utils';
+import { toBitsString } from '../../utils';
+import { getVersion } from '../encoding';
+
+const BYTE = "byte";
+
+export class Utf8Encoder extends Class {
+    constructor() {
+        super();
+
+        this.initProperties();
+
+        this.mode = DataModeInstances[this.encodingMode];
+    }
+
+    initProperties() {
+        extend(this, {
+            encodingMode: BYTE,
+            utfBOM: "111011111011101110111111",
+            initialModeCountStringLength: 20,
+            ranges: [128, 2048, 65536, 2097152, 67108864]
+        });
+    }
+
+    getEncodingResult(inputString, errorCorrectionLevel) {
+        let data = this.encode(inputString),
+            dataCodewordsCount = this.getDataCodewordsCount(data),
+            version = getVersion(dataCodewordsCount, errorCorrectionLevel),
+            dataString = this.mode.getModeCountString(data.length / 8, version) + data;
+
+        return new EncodingResult(dataString, version);
+    }
+
+    getDataCodewordsCount(data) {
+        let dataLength = data.length,
+            dataCodewordsCount = Math.ceil((this.initialModeCountStringLength + dataLength) / 8);
+
+        return dataCodewordsCount;
+    }
+
+    encode(str) {
+        let result = this.utfBOM;
+
+        for (let i = 0; i < str.length; i++) {
+            result += this.encodeCharacter(str.charCodeAt(i));
+        }
+
+        return result;
+    }
+
+    encodeCharacter(code) {
+        let bytesCount = this.getBytesCount(code),
+            bc = bytesCount - 1,
+            result = "";
+
+        if (bytesCount === 1) {
+            result = toBitsString(code, 8);
+        } else {
+            let significantOnes = 8 - bytesCount;
+
+            for (let i = 0; i < bc; i++) {
+                result = toBitsString(code >> (i * 6) & 63 | 128, 8) + result;
+            }
+
+            result = ((code >> bc * 6) | ((255 >> significantOnes) << significantOnes)).toString(2) + result;
+        }
+
+        return result;
+    }
+
+    getBytesCount(code) {
+        let ranges = this.ranges;
+
+        for (let i = 0; i < ranges.length; i++) {
+            if (code < ranges[i]) {
+                return i + 1;
+            }
+        }
+    }
+}

package/dist/es2015/qrcode/encodings/encoding-result.js

@@ -0,0 +1,10 @@
+import { Class } from '../../common';
+
+export class EncodingResult extends Class {
+    constructor(dataString, version) {
+        super();
+
+        this.dataString = dataString;
+        this.version = version;
+    }
+}