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

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

@@ -0,0 +1,103 @@
+import { QRDataMode } from './qr-data-mode';
+import { extend } from '../../utils';
+import {
+    toBitsString,
+    splitInto
+} from '../../utils';
+
+export var AlphaNumericQRDataMode = (function (QRDataMode) {
+    function AlphaNumericQRDataMode () {
+        QRDataMode.apply(this, arguments);
+    }
+
+    if ( QRDataMode ) AlphaNumericQRDataMode.__proto__ = QRDataMode;
+    AlphaNumericQRDataMode.prototype = Object.create( QRDataMode && QRDataMode.prototype );
+    AlphaNumericQRDataMode.prototype.constructor = AlphaNumericQRDataMode;
+
+    AlphaNumericQRDataMode.prototype.initProperties = function initProperties () {
+        QRDataMode.prototype.initProperties.call(this);
+
+        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"
+        });
+    };
+
+    AlphaNumericQRDataMode.prototype.getValue = function getValue (character) {
+        return this.characters[character];
+    };
+
+    AlphaNumericQRDataMode.prototype.encode = function encode (str, version) {
+        var this$1 = this;
+
+        var
+            parts = splitInto(str, 2),
+            result = this.getModeCountString(str.length, version),
+            value;
+        var i;
+
+        for (i = 0; i < parts.length - 1; i++) {
+            value = 45 * this$1.getValue(parts[i].charAt(0)) + this$1.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);
+    };
+
+    AlphaNumericQRDataMode.prototype.getStringBitsLength = function getStringBitsLength (inputLength, version) {
+        return 4 + this.getBitsCharacterCount(version) + 11 * Math.floor(inputLength / 2) + 6 * (inputLength % 2);
+    };
+
+    return AlphaNumericQRDataMode;
+}(QRDataMode));

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

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

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

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

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

@@ -0,0 +1,49 @@
+import { QRDataMode } from './qr-data-mode';
+import { extend } from '../../utils';
+import {
+    toBitsString,
+    splitInto
+} from '../../utils';
+
+export var NumericQRDataMode = (function (QRDataMode) {
+    function NumericQRDataMode () {
+        QRDataMode.apply(this, arguments);
+    }
+
+    if ( QRDataMode ) NumericQRDataMode.__proto__ = QRDataMode;
+    NumericQRDataMode.prototype = Object.create( QRDataMode && QRDataMode.prototype );
+    NumericQRDataMode.prototype.constructor = NumericQRDataMode;
+
+    NumericQRDataMode.prototype.initProperties = function initProperties () {
+        QRDataMode.prototype.initProperties.call(this);
+
+        extend(this, {
+            bitsInCharacterCount: [10, 12, 14],
+            modeIndicator: "0001"
+        });
+    };
+
+    NumericQRDataMode.prototype.getValue = function getValue (character) {
+        return parseInt(character, 10);
+    };
+
+    NumericQRDataMode.prototype.encode = function encode (str, version) {
+        var mode = this,
+            parts = splitInto(str, 3),
+            result = mode.getModeCountString(str.length, version);
+        var i;
+
+        for (i = 0; i < parts.length - 1; i++) {
+            result += toBitsString(parts[i], 10);
+        }
+
+        return result + toBitsString(parts[i], 1 + 3 * parts[i].length);
+    };
+
+    NumericQRDataMode.prototype.getStringBitsLength = function getStringBitsLength (inputLength, version) {
+        var mod3 = inputLength % 3;
+        return 4 + this.getBitsCharacterCount(version) + 10 * Math.floor(inputLength / 3) + 3 * mod3 + (mod3 === 0 ? 0 : 1);
+    };
+
+    return NumericQRDataMode;
+}(QRDataMode));

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

@@ -0,0 +1,50 @@
+import { Class } from '../../../common';
+import { extend } from '../../utils';
+import {
+    toBitsString
+} from '../../utils';
+
+export var QRDataMode = (function (Class) {
+    function QRDataMode() {
+        Class.call(this);
+
+        this.initProperties();
+    }
+
+    if ( Class ) QRDataMode.__proto__ = Class;
+    QRDataMode.prototype = Object.create( Class && Class.prototype );
+    QRDataMode.prototype.constructor = QRDataMode;
+
+    QRDataMode.prototype.initProperties = function initProperties () {
+        extend(this, {
+            modeIndicator: "",
+            bitsInCharacterCount: []
+        });
+    };
+
+    QRDataMode.prototype.getVersionIndex = function getVersionIndex (version) {
+        if (version < 10) {
+            return 0;
+        } else if (version > 26) {
+            return 2;
+        }
+
+        return 1;
+    };
+
+    QRDataMode.prototype.getBitsCharacterCount = function getBitsCharacterCount (version) {
+        return this.bitsInCharacterCount[this.getVersionIndex(version || 40)];
+    };
+
+    QRDataMode.prototype.getModeCountString = function getModeCountString (length, version) {
+        return this.modeIndicator + toBitsString(length, this.getBitsCharacterCount(version));
+    };
+
+    QRDataMode.prototype.encode = function encode () { };
+
+    QRDataMode.prototype.getStringBitsLength = function getStringBitsLength () { };
+
+    QRDataMode.prototype.getValue = function getValue () { };
+
+    return QRDataMode;
+}(Class));

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

@@ -0,0 +1,29 @@
+import { Class } from '../../../common';
+import { EncodingResult } from '../encoding-result';
+import {
+    getModes,
+    getVersion,
+    getDataCodewordsCount,
+    getDataString
+} from '../encoding';
+
+export var IsoEncoder = (function (Class) {
+    function IsoEncoder () {
+        Class.apply(this, arguments);
+    }
+
+    if ( Class ) IsoEncoder.__proto__ = Class;
+    IsoEncoder.prototype = Object.create( Class && Class.prototype );
+    IsoEncoder.prototype.constructor = IsoEncoder;
+
+    IsoEncoder.prototype.getEncodingResult = function getEncodingResult (inputString, errorCorrectionLevel) {
+        var modes = getModes(inputString),
+            dataCodewordsCount = getDataCodewordsCount(modes),
+            version = getVersion(dataCodewordsCount, errorCorrectionLevel),
+            dataString = getDataString(modes, version);
+
+        return new EncodingResult(dataString, version);
+    };
+
+    return IsoEncoder;
+}(Class));

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

@@ -0,0 +1,91 @@
+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';
+
+var BYTE = "byte";
+
+export var Utf8Encoder = (function (Class) {
+    function Utf8Encoder() {
+        Class.call(this);
+
+        this.initProperties();
+
+        this.mode = DataModeInstances[this.encodingMode];
+    }
+
+    if ( Class ) Utf8Encoder.__proto__ = Class;
+    Utf8Encoder.prototype = Object.create( Class && Class.prototype );
+    Utf8Encoder.prototype.constructor = Utf8Encoder;
+
+    Utf8Encoder.prototype.initProperties = function initProperties () {
+        extend(this, {
+            encodingMode: BYTE,
+            utfBOM: "111011111011101110111111",
+            initialModeCountStringLength: 20,
+            ranges: [128, 2048, 65536, 2097152, 67108864]
+        });
+    };
+
+    Utf8Encoder.prototype.getEncodingResult = function getEncodingResult (inputString, errorCorrectionLevel) {
+        var 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);
+    };
+
+    Utf8Encoder.prototype.getDataCodewordsCount = function getDataCodewordsCount (data) {
+        var dataLength = data.length,
+            dataCodewordsCount = Math.ceil((this.initialModeCountStringLength + dataLength) / 8);
+
+        return dataCodewordsCount;
+    };
+
+    Utf8Encoder.prototype.encode = function encode (str) {
+        var this$1 = this;
+
+        var result = this.utfBOM;
+
+        for (var i = 0; i < str.length; i++) {
+            result += this$1.encodeCharacter(str.charCodeAt(i));
+        }
+
+        return result;
+    };
+
+    Utf8Encoder.prototype.encodeCharacter = function encodeCharacter (code) {
+        var bytesCount = this.getBytesCount(code),
+            bc = bytesCount - 1,
+            result = "";
+
+        if (bytesCount === 1) {
+            result = toBitsString(code, 8);
+        } else {
+            var significantOnes = 8 - bytesCount;
+
+            for (var 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;
+    };
+
+    Utf8Encoder.prototype.getBytesCount = function getBytesCount (code) {
+        var ranges = this.ranges;
+
+        for (var i = 0; i < ranges.length; i++) {
+            if (code < ranges[i]) {
+                return i + 1;
+            }
+        }
+    };
+
+    return Utf8Encoder;
+}(Class));

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

@@ -0,0 +1,16 @@
+import { Class } from '../../common';
+
+export var EncodingResult = (function (Class) {
+    function EncodingResult(dataString, version) {
+        Class.call(this);
+
+        this.dataString = dataString;
+        this.version = version;
+    }
+
+    if ( Class ) EncodingResult.__proto__ = Class;
+    EncodingResult.prototype = Object.create( Class && Class.prototype );
+    EncodingResult.prototype.constructor = EncodingResult;
+
+    return EncodingResult;
+}(Class));