@progress/kendo-charts 2.7.2-dev.202502101310 → 2.7.2-develop.1

package/dist/es/qrcode/encodings/free-cell-visitor.js

@@ -1,8 +1,8 @@
 import { Class } from '../../common';
 
-export var FreeCellVisitor = (function (Class) {
-    function FreeCellVisitor(matrix) {
-        Class.call(this);
+export class FreeCellVisitor extends Class {
+    constructor(matrix) {
+        super();
 
         this.matrix = matrix;
         this.row = matrix.length - 1;
@@ -12,27 +12,21 @@ export var FreeCellVisitor = (function (Class) {
         this.c = 0;
     }
 
-    if ( Class ) FreeCellVisitor.__proto__ = Class;
-    FreeCellVisitor.prototype = Object.create( Class && Class.prototype );
-    FreeCellVisitor.prototype.constructor = FreeCellVisitor;
-
-    FreeCellVisitor.prototype.move = function move () {
+    move() {
         this.row += this.dir * this.c;
         this.c ^= 1;
         this.column = this.startColumn - this.c;
-    };
-
-    FreeCellVisitor.prototype.getNextCell = function getNextCell () {
-        var this$1 = this;
+    }
 
+    getNextCell() {
         while (this.matrix[this.row][this.column] !== undefined) {
-            this$1.move();
+            this.move();
 
-            if (this$1.row < 0 || this$1.row >= this$1.matrix.length) {
-                this$1.dir = -this$1.dir;
-                this$1.startColumn -= this$1.startColumn !== 8 ? 2 : 3;
-                this$1.column = this$1.startColumn;
-                this$1.row = this$1.dir < 0 ? this$1.matrix.length - 1 : 0;
+            if (this.row < 0 || this.row >= this.matrix.length) {
+                this.dir = -this.dir;
+                this.startColumn -= this.startColumn !== 8 ? 2 : 3;
+                this.column = this.startColumn;
+                this.row = this.dir < 0 ? this.matrix.length - 1 : 0;
             }
         }
 
@@ -40,9 +34,9 @@ export var FreeCellVisitor = (function (Class) {
             row: this.row,
             column: this.column
         };
-    };
+    }
 
-    FreeCellVisitor.prototype.getNextRemainderCell = function getNextRemainderCell () {
+    getNextRemainderCell() {
         this.move();
 
         if (this.matrix[this.row][this.column] === undefined) {
@@ -51,7 +45,5 @@ export var FreeCellVisitor = (function (Class) {
                 column: this.column
             };
         }
-    };
-
-    return FreeCellVisitor;
-}(Class));
+    }
+}

package/dist/es/qrcode/encodings/utils/choose-mode.js

@@ -0,0 +1,44 @@
+const NUMERIC = "numeric";
+const ALPHA_NUMERIC = "alphanumeric";
+const BYTE = "byte";
+const numberRegex = /^\d+/;
+const alphaPattern = "A-Z0-9 $%*+./:-";
+const alphaExclusiveSet = "A-Z $%*+./:-";
+const alphaRegex = new RegExp("^[" + alphaExclusiveSet + "]+");
+const alphaNumericRegex = new RegExp("^[" + alphaPattern + "]+");
+const byteRegex = new RegExp("^[^" + alphaPattern + "]+");
+
+export function chooseMode(str, minNumericBeforeAlpha, minNumericBeforeByte, minAlphaBeforeByte, previousMode) {
+    let numeric = numberRegex.exec(str),
+        numericMatch = numeric ? numeric[0] : "",
+        alpha = alphaRegex.exec(str),
+        alphaMatch = alpha ? alpha[0] : "",
+        alphaNumeric = alphaNumericRegex.exec(str),
+        alphaNumericMatch = alphaNumeric ? alphaNumeric[0] : "",
+        mode,
+        modeString;
+
+    if (numericMatch &&
+        (numericMatch.length >= minNumericBeforeAlpha || str.length === numericMatch.length ||
+            (numericMatch.length >= minNumericBeforeByte && !alphaNumericRegex.test(str.charAt(numericMatch.length))))) {
+        mode = NUMERIC;
+        modeString = numericMatch;
+    } else if (alphaNumericMatch && (str.length === alphaNumericMatch.length ||
+        alphaNumericMatch.length >= minAlphaBeforeByte || previousMode === ALPHA_NUMERIC)) {
+        mode = ALPHA_NUMERIC;
+        modeString = numericMatch || alphaMatch;
+    } else {
+        mode = BYTE;
+
+        if (alphaNumericMatch) {
+            modeString = alphaNumericMatch + byteRegex.exec(str.substring(alphaNumericMatch.length))[0];
+        } else {
+            modeString = byteRegex.exec(str)[0];
+        }
+    }
+
+    return {
+        mode: mode,
+        modeString: modeString
+    };
+}

package/dist/es/qrcode/encodings/utils/get-data-codewords-count.js

@@ -0,0 +1,13 @@
+import { DataModeInstances } from '../data-modes/data-mode-instances';
+
+export function getDataCodewordsCount(modes) {
+    let length = 0,
+        mode;
+
+    for (let i = 0; i < modes.length; i++) {
+        mode = DataModeInstances[modes[i].mode];
+        length += mode.getStringBitsLength(modes[i].modeString.length);
+    }
+
+    return Math.ceil(length / 8);
+}

package/dist/es/qrcode/encodings/utils/get-data-string.js

@@ -0,0 +1,13 @@
+import { DataModeInstances } from '../data-modes/data-mode-instances';
+
+export function getDataString(modes, version) {
+    let dataString = "",
+        mode;
+
+    for (let i = 0; i < modes.length; i++) {
+        mode = DataModeInstances[modes[i].mode];
+        dataString += mode.encode(modes[i].modeString, version);
+    }
+
+    return dataString;
+}

package/dist/es/qrcode/encodings/utils/get-modes.js

@@ -0,0 +1,35 @@
+import { chooseMode } from './choose-mode';
+
+const initMinNumericBeforeAlpha = 8;
+const initMinNumericBeforeByte = 5;
+const initMinAlphaBeforeByte = 8;
+const minNumericBeforeAlpha = 17;
+const minNumericBeforeByte = 9;
+const minAlphaBeforeByte = 16;
+
+export function getModes(inputString) {
+    let modes = [],
+        previousMode,
+        idx = 0;
+    let str = inputString;
+
+    modes.push(chooseMode(str, initMinNumericBeforeAlpha, initMinNumericBeforeByte, initMinAlphaBeforeByte, previousMode));
+    previousMode = modes[0].mode;
+    str = str.substr(modes[0].modeString.length);
+
+    while (str.length > 0) {
+        let nextMode = chooseMode(str, minNumericBeforeAlpha, minNumericBeforeByte, minAlphaBeforeByte, previousMode);
+
+        if (nextMode.mode !== previousMode) {
+            previousMode = nextMode.mode;
+            modes.push(nextMode);
+            idx++;
+        } else {
+            modes[idx].modeString += nextMode.modeString;
+        }
+
+        str = str.substr(nextMode.modeString.length);
+    }
+
+    return modes;
+}

package/dist/es/qrcode/encodings/utils/get-version.js

@@ -0,0 +1,23 @@
+import { VersionsCodewordsInformation } from '../version-codewords';
+
+export function getVersion(dataCodewordsCount, errorCorrectionLevel) {
+    let x = 0,
+        y = VersionsCodewordsInformation.length - 1,
+        version = Math.floor(VersionsCodewordsInformation.length / 2);
+
+    do {
+        if (dataCodewordsCount < VersionsCodewordsInformation[version][errorCorrectionLevel].totalDataCodewords) {
+            y = version;
+        } else {
+            x = version;
+        }
+
+        version = x + Math.floor((y - x) / 2);
+    } while (y - x > 1);
+
+    if (dataCodewordsCount <= VersionsCodewordsInformation[x][errorCorrectionLevel].totalDataCodewords) {
+        return version + 1;
+    }
+
+    return y + 1;
+}

package/dist/es/qrcode/encodings/utils/index.js

@@ -0,0 +1,5 @@
+export * from './choose-mode';
+export * from './get-data-codewords-count';
+export * from './get-data-string';
+export * from './get-modes';
+export * from './get-version';

package/dist/es/qrcode/encodings/version-codewords.js

@@ -1,4 +1,4 @@
-export var VersionsCodewordsInformation = [{
+export const VersionsCodewordsInformation = [{
     L: {
         groups: [
             [1, 19]

package/dist/es/qrcode/qrcode-validator.js

@@ -1,17 +1,15 @@
 import { encodeData } from './encodings/encoding';
 
-var ISO = 'ISO_8859_1';
-
-function qrcodeValidator(encoding) {
-    if ( encoding === void 0 ) encoding = ISO;
+const ISO = 'ISO_8859_1';
 
+function qrcodeValidator(encoding = ISO) {
     return function(value) {
         try {
             encodeData(value, 'L', encoding);
         } catch (error) {
             return {
                 valid: false,
-                error: error
+                error
             };
         }
 

package/dist/es/qrcode/qrcode.js

@@ -17,11 +17,11 @@ import { extend } from './utils';
 
 import { surfaceSize } from '../barcode/surface-size';
 
-var round = Math.round;
-var crossPattern = [[0, 1], [1, 1], [1, 2], [2, 2], [2, 1], [3, 1], [3, 0], [2, 0], [2, -1], [1, -1], [1, 0]];
-var squarePattern = [[0, 1], [1, 1], [1, 0]];
+const round = Math.round;
+const crossPattern = [[0, 1], [1, 1], [1, 2], [2, 2], [2, 1], [3, 1], [3, 0], [2, 0], [2, -1], [1, -1], [1, 0]];
+const squarePattern = [[0, 1], [1, 1], [1, 0]];
 
-var QRCodeDefaults = {
+const QRCodeDefaults = {
     DEFAULT_SIZE: 200,
     QUIET_ZONE_LENGTH: 4,
     DEFAULT_ERROR_CORRECTION_LEVEL: "L",
@@ -31,11 +31,9 @@ var QRCodeDefaults = {
     DEFAULT_LOGO_SIZE: 7
 };
 
-var QRCode = (function (Class) {
-    function QRCode(element, options, errorHandler) {
-        if ( errorHandler === void 0 ) errorHandler = defaultErrorHandler;
-
-        Class.call(this);
+class QRCode extends Class {
+    constructor(element, options, errorHandler = defaultErrorHandler) {
+        super();
 
         this.options = deepExtend({}, this.options, options);
         this.element = element;
@@ -48,61 +46,55 @@ var QRCode = (function (Class) {
         this.setOptions(options);
     }
 
-    if ( Class ) QRCode.__proto__ = Class;
-    QRCode.prototype = Object.create( Class && Class.prototype );
-    QRCode.prototype.constructor = QRCode;
-
-    QRCode.prototype.destroy = function destroy () {
+    destroy() {
         this._destroySurface();
-    };
+    }
 
-    QRCode.prototype._initElement = function _initElement () {
+    _initElement() {
         addClass(this.element, "k-qrcode");
-    };
+    }
 
-    QRCode.prototype._initSurface = function _initSurface () {
-        var ref = this;
-        var options = ref.options;
-        var surface = ref.surface;
+    _initSurface() {
+        const { options, surface } = this;
 
         if (!surface || surface.options.type !== options.renderAs) {
             this._destroySurface();
             this._initSurfaceElement();
             this.surface = this._createSurface();
         }
-    };
+    }
 
-    QRCode.prototype._createSurface = function _createSurface () {
+    _createSurface() {
         return draw.Surface.create(this.surfaceElement, {
             type: this.options.renderAs
         });
-    };
+    }
 
-    QRCode.prototype._destroySurface = function _destroySurface () {
+    _destroySurface() {
         if (this.surface) {
             this.surface.destroy();
             this.surface = null;
             this._destroySurfaceElement();
         }
-    };
+    }
 
-    QRCode.prototype._initSurfaceElement = function _initSurfaceElement () {
+    _initSurfaceElement() {
         if (!this.surfaceElement) {
             this.surfaceElement = document.createElement('div');
             this.surfaceElement.style.position = "relative";
             this.element.appendChild(this.surfaceElement);
         }
-    };
+    }
 
-    QRCode.prototype._destroySurfaceElement = function _destroySurfaceElement () {
+    _destroySurfaceElement() {
         if (this.surfaceElement && this.surfaceElement.parentNode) {
             this.surfaceElement.parentNode.removeChild(this.surfaceElement);
             this.surfaceElement = null;
         }
-    };
+    }
 
-    QRCode.prototype.redraw = function redraw () {
-        var size = this._getSize();
+    redraw() {
+        let size = this._getSize();
 
         this.surface.clear();
 
@@ -114,13 +106,13 @@ var QRCode = (function (Class) {
         this.createVisual();
 
         this.surface.draw(this.visual);
-    };
+    }
 
-    QRCode.prototype.getSize = function getSize () {
-        var element = this.element;
-        var elementWidth = element.clientWidth;
-        var elementHeight = element.clientHeight;
-        var size = { width: 0, height: 0 };
+    getSize() {
+        const element = this.element;
+        const elementWidth = element.clientWidth;
+        const elementHeight = element.clientHeight;
+        const size = { width: 0, height: 0 };
 
         if (elementWidth > 0) {
             size.width = elementWidth;
@@ -131,22 +123,22 @@ var QRCode = (function (Class) {
         }
 
         return size;
-    };
+    }
 
-    QRCode.prototype._resize = function _resize () {
+    _resize() {
         this.redraw();
-    };
+    }
 
-    QRCode.prototype.createVisual = function createVisual () {
+    createVisual() {
         this.visual = this._render();
-    };
+    }
 
-    QRCode.prototype.exportVisual = function exportVisual () {
+    exportVisual() {
         return this._render();
-    };
+    }
 
-    QRCode.prototype._render = function _render () {
-        var value = this._value,
+    _render() {
+        let value = this._value,
             baseUnit,
             border = this.options.border || {},
             padding = this.options.padding || 0,
@@ -159,7 +151,7 @@ var QRCode = (function (Class) {
 
         border.width = borderWidth;
 
-        var visual = new draw.Group();
+        let visual = new draw.Group();
 
         try {
             if (value) {
@@ -184,15 +176,15 @@ var QRCode = (function (Class) {
         }
 
         return visual;
-    };
-
-    QRCode.prototype._renderLogo = function _renderLogo (qrSize, baseUnit) {
-        var image;
-        var imageRect;
-        var center = round(qrSize / 2);
-        var logoSize = this._getLogoSize(baseUnit * QRCodeDefaults.DEFAULT_LOGO_SIZE);
-        var logoUrl = this.options.overlay.imageUrl;
-        var position = {
+    }
+
+    _renderLogo(qrSize, baseUnit) {
+        let image;
+        let imageRect;
+        let center = round(qrSize / 2);
+        let logoSize = this._getLogoSize(baseUnit * QRCodeDefaults.DEFAULT_LOGO_SIZE);
+        let logoUrl = this.options.overlay.imageUrl;
+        let position = {
             x: center - logoSize.width / 2,
             y: center - logoSize.height / 2
         };
@@ -205,16 +197,16 @@ var QRCode = (function (Class) {
         image = new draw.Image(logoUrl, imageRect);
 
         return image;
-    };
+    }
 
-    QRCode.prototype._renderSwissCode = function _renderSwissCode (qrSize, baseUnit) {
-        var logoSize = this._getLogoSize(baseUnit * QRCodeDefaults.DEFAULT_LOGO_SIZE);
+    _renderSwissCode(qrSize, baseUnit) {
+        let logoSize = this._getLogoSize(baseUnit * QRCodeDefaults.DEFAULT_LOGO_SIZE);
         logoSize = Math.max(logoSize.width, logoSize.height);
-        var crossSize = logoSize / 4;
-        var crossOffset = crossSize / 2;
-        var center = qrSize / 2;
-        var start = {};
-        var visual = new draw.Group();
+        let crossSize = logoSize / 4;
+        let crossOffset = crossSize / 2;
+        let center = qrSize / 2;
+        let start = {};
+        let visual = new draw.Group();
 
         start.x = start.y = Math.ceil(center - baseUnit - logoSize / 2);
         visual.append(this._renderShape(start, Math.ceil(logoSize + baseUnit * 2), squarePattern, "#fff"));
@@ -227,10 +219,10 @@ var QRCode = (function (Class) {
         visual.append(this._renderShape(start, crossSize, crossPattern, "#fff"));
 
         return visual;
-    };
+    }
 
-    QRCode.prototype._renderShape = function _renderShape (start, step, pattern, color) {
-        var path = new draw.MultiPath({
+    _renderShape(start, step, pattern, color) {
+        let path = new draw.MultiPath({
             fill: {
                 color: color
             },
@@ -239,24 +231,24 @@ var QRCode = (function (Class) {
 
         path.moveTo(start.x, start.y);
 
-        for (var i = 0; i < pattern.length; i++) {
+        for (let i = 0; i < pattern.length; i++) {
             path.lineTo(start.x + step * pattern[i][0], start.y + step * pattern[i][1]);
         }
 
         path.close();
 
         return path;
-    };
+    }
 
-    QRCode.prototype._getSize = function _getSize () {
-        var size;
+    _getSize() {
+        let size;
 
         if (this.options.size) {
             size = parseInt(this.options.size, 10);
         } else {
-            var element = this.element;
-            var elementSize = surfaceSize(element, this.options.renderAs);
-            var min = Math.min(elementSize.width, elementSize.height);
+            const element = this.element;
+            const elementSize = surfaceSize(element, this.options.renderAs);
+            const min = Math.min(elementSize.width, elementSize.height);
 
             if (min > 0) {
                 size = min;
@@ -266,15 +258,15 @@ var QRCode = (function (Class) {
         }
 
         return size;
-    };
+    }
 
-    QRCode.prototype._calculateBaseUnit = function _calculateBaseUnit (size, matrixSize) {
-        var baseUnit = Math.floor(size / matrixSize);
+    _calculateBaseUnit(size, matrixSize) {
+        let baseUnit = Math.floor(size / matrixSize);
 
         if (baseUnit < QRCodeDefaults.MIN_BASE_UNIT_SIZE) {
-            var minSize = Math.ceil(matrixSize * QRCodeDefaults.MIN_BASE_UNIT_SIZE);
+            const minSize = Math.ceil(matrixSize * QRCodeDefaults.MIN_BASE_UNIT_SIZE);
             this.onError(new Error(
-                ("Insufficient size for QR Code: the current size is " + size + "px and the minimum size is " + minSize + "px.")
+                `Insufficient size for QR Code: the current size is ${size}px and the minimum size is ${minSize}px.`
             ));
         } else if (baseUnit * matrixSize >= size &&
             baseUnit - 1 >= QRCodeDefaults.MIN_BASE_UNIT_SIZE) {
@@ -282,19 +274,19 @@ var QRCode = (function (Class) {
         }
 
         return baseUnit;
-    };
+    }
 
-    QRCode.prototype._renderMatrix = function _renderMatrix (matrix, baseUnit, quietZoneSize) {
-        var path = new draw.MultiPath({
+    _renderMatrix(matrix, baseUnit, quietZoneSize) {
+        let path = new draw.MultiPath({
             fill: {
                 color: this.options.color
             },
             stroke: null
         });
 
-        for (var row = 0; row < matrix.length; row++) {
-            var y = quietZoneSize + row * baseUnit;
-            var column = 0;
+        for (let row = 0; row < matrix.length; row++) {
+            let y = quietZoneSize + row * baseUnit;
+            let column = 0;
 
             while (column < matrix.length) {
                 while (matrix[row][column] === 0 && column < matrix.length) {
@@ -302,15 +294,15 @@ var QRCode = (function (Class) {
                 }
 
                 if (column < matrix.length) {
-                    var x = column;
+                    let x = column;
                     while (matrix[row][column] === 1) {
                         column++;
                     }
 
-                    var x1 = round(quietZoneSize + x * baseUnit);
-                    var y1 = round(y);
-                    var x2 = round(quietZoneSize + column * baseUnit);
-                    var y2 = round(y + baseUnit);
+                    let x1 = round(quietZoneSize + x * baseUnit);
+                    let y1 = round(y);
+                    let x2 = round(quietZoneSize + column * baseUnit);
+                    let y2 = round(y + baseUnit);
 
                     path.moveTo(x1, y1)
                         .lineTo(x1, y2)
@@ -322,11 +314,11 @@ var QRCode = (function (Class) {
         }
 
         return path;
-    };
+    }
 
-    QRCode.prototype._renderBackground = function _renderBackground (size, border) {
-        var box = new Box(0, 0, size, size).unpad(border.width / 2);
-        var background = draw.Path.fromRect(box.toRect(), {
+    _renderBackground(size, border) {
+        const box = new Box(0, 0, size, size).unpad(border.width / 2);
+        const background = draw.Path.fromRect(box.toRect(), {
             fill: {
                 color: this.options.background
             },
@@ -337,10 +329,10 @@ var QRCode = (function (Class) {
         });
 
         return background;
-    };
+    }
 
-    QRCode.prototype.setOptions = function setOptions (options) {
-        var newOptions = options || {};
+    setOptions(options) {
+        let newOptions = options || {};
         this.options = extend(this.options, newOptions);
 
         if (options.value !== undefined) {
@@ -349,29 +341,29 @@ var QRCode = (function (Class) {
 
         this._initSurface();
         this.redraw();
-    };
+    }
 
-    QRCode.prototype.value = function value (value$1) {
-        if (value$1 === undefined) {
+    value(value) {
+        if (value === undefined) {
             return this._value;
         }
 
-        this._value = String(value$1);
+        this._value = String(value);
 
         this.redraw();
-    };
+    }
 
-    QRCode.prototype._hasCustomLogo = function _hasCustomLogo () {
+    _hasCustomLogo() {
         return Boolean(this.options.overlay.imageUrl);
-    };
+    }
 
-    QRCode.prototype._isSwiss = function _isSwiss () {
+    _isSwiss() {
         return this.options.overlay.type === "swiss";
-    };
+    }
 
-    QRCode.prototype._getLogoSize = function _getLogoSize (defautLogoSize) {
-        var width = this.options.overlay.width;
-        var height = this.options.overlay.height;
+    _getLogoSize(defautLogoSize) {
+        let width = this.options.overlay.width;
+        let height = this.options.overlay.height;
 
         if (!width && !height) {
             width = height = defautLogoSize;
@@ -385,10 +377,8 @@ var QRCode = (function (Class) {
             width: width,
             height: height
         };
-    };
-
-    return QRCode;
-}(Class));
+    }
+}
 
 setDefaultOptions(QRCode, {
     name: "QRCode",

package/dist/es/qrcode/utils.js

@@ -1,8 +1,8 @@
-export var extend = Object.assign;
+export const extend = Object.assign;
 
 export function splitInto(str, chunkLength) {
-    var result = [];
-    var idx = 0;
+    let result = [];
+    let idx = 0;
 
     while (idx < str.length) {
         result.push(str.substring(idx, idx + chunkLength));
@@ -13,7 +13,7 @@ export function splitInto(str, chunkLength) {
 }
 
 export function toBitsString(value, length) {
-    var bitString = Number(value).toString(2);
+    let bitString = Number(value).toString(2);
 
     if (bitString.length < length) {
         bitString = new Array(length - bitString.length + 1).join(0) + bitString;