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

package/dist/es/barcode/encodings/code39-extended.js

@@ -1,8 +1,8 @@
 import { Code39 } from './code39';
 import deepExtend from '../../common/deep-extend';
 
-export var Code39ExtendedBase = {
-    addCharacter: function addCharacter(character) {
+export const Code39ExtendedBase = {
+    addCharacter(character) {
         if (this.characterMap[character]) {
             this.addBase(this.characterMap[character]);
         } else if (character.charCodeAt(0) > 127) {
@@ -12,21 +12,19 @@ export var Code39ExtendedBase = {
         }
     },
 
-    addExtended: function addExtended(code) {
-        var this$1 = this;
+    addExtended(code) {
+        let patterns;
 
-        var patterns;
-
-        for (var i = 0; i < this.extendedMappings.length; i++) {
-            patterns = this$1.extendedMappings[i].call(this$1, code);
+        for (let i = 0; i < this.extendedMappings.length; i++) {
+            patterns = this.extendedMappings[i].call(this, code);
 
             if (patterns) {
-                for (var patternIndex = 0; patternIndex < patterns.length; patternIndex++) {
-                    var pattern = patterns[patternIndex];
-                    this$1.addBase(pattern);
+                for (let patternIndex = 0; patternIndex < patterns.length; patternIndex++) {
+                    const pattern = patterns[patternIndex];
+                    this.addBase(pattern);
                 }
 
-                this$1.dataLength += patterns.length - 1;
+                this.dataLength += patterns.length - 1;
                 return;
             }
         }
@@ -49,10 +47,8 @@ export var Code39ExtendedBase = {
             }
         },
         function(code) {
-            var this$1 = this;
-
-            var result;
-            var dataCharacter;
+            let result;
+            let dataCharacter;
 
             if (!this.specialAsciiCodes[code]) {
                 dataCharacter = Math.floor(code / 32) * 6 + (code - 27) % 32 + 64;
@@ -60,9 +56,9 @@ export var Code39ExtendedBase = {
             } else {
                 result = [];
 
-                for (var i = 0; i < this.specialAsciiCodes[code].length; i++) {
-                    result.push(this$1.characterMap[this$1.shiftCharacters[3]]);
-                    result.push(this$1.characterMap[this$1.specialAsciiCodes[code][i]]);
+                for (let i = 0; i < this.specialAsciiCodes[code].length; i++) {
+                    result.push(this.characterMap[this.shiftCharacters[3]]);
+                    result.push(this.characterMap[this.specialAsciiCodes[code][i]]);
                 }
             }
 
@@ -90,17 +86,9 @@ export var Code39ExtendedBase = {
     shiftCharacters: ["SHIFT0", "SHIFT1", "SHIFT2", "SHIFT3"]
 };
 
-export var Code39Extended = (function (Code39) {
-    function Code39Extended () {
-        Code39.apply(this, arguments);
-    }
-
-    if ( Code39 ) Code39Extended.__proto__ = Code39;
-    Code39Extended.prototype = Object.create( Code39 && Code39.prototype );
-    Code39Extended.prototype.constructor = Code39Extended;
-
-    Code39Extended.prototype.initProperties = function initProperties () {
-        Code39.prototype.initProperties.call(this);
+export class Code39Extended extends Code39 {
+    initProperties() {
+        super.initProperties();
 
         deepExtend(this, Code39ExtendedBase, {
             name: "Code 39 extended",
@@ -111,7 +99,5 @@ export var Code39Extended = (function (Code39) {
                 SHIFT3: { "pattern": "bwbWbWbWb", "value": 42 }
             }
         });
-    };
-
-    return Code39Extended;
-}(Code39));
+    }
+}

package/dist/es/barcode/encodings/code39.js

@@ -1,34 +1,24 @@
 import { setDefaultOptions } from '../../common';
 import { Encoding } from './encoding';
 
-var extend = Object.assign;
+const extend = Object.assign;
 
-export var Code39Base = (function (Encoding) {
-    function Code39Base () {
-        Encoding.apply(this, arguments);
-    }
-
-    if ( Encoding ) Code39Base.__proto__ = Encoding;
-    Code39Base.prototype = Object.create( Encoding && Encoding.prototype );
-    Code39Base.prototype.constructor = Code39Base;
-
-    Code39Base.prototype.initProperties = function initProperties () {
-        Encoding.prototype.initProperties.call(this);
+export class Code39Base extends Encoding {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             minBaseUnitLength: 0.7
         });
-    };
-
-    Code39Base.prototype.addData = function addData () {
-        var this$1 = this;
+    }
 
-        var value = this.value;
+    addData() {
+        const value = this.value;
 
         this.addStart();
 
-        for (var idx = 0; idx < value.length; idx++) {
-            this$1.addCharacter(value.charAt(idx));
+        for (let idx = 0; idx < value.length; idx++) {
+            this.addCharacter(value.charAt(idx));
         }
 
         if (this.options.addCheckSum) {
@@ -37,34 +27,24 @@ export var Code39Base = (function (Encoding) {
 
         this.addStop();
         this.prepareValues();
-    };
+    }
 
-    Code39Base.prototype.addCharacter = function addCharacter (character) {
-        var characterData = this.characterMap[character];
+    addCharacter(character) {
+        const characterData = this.characterMap[character];
 
         if (!characterData) {
             this.invalidCharacterError(character);
         }
 
         this.addBase(characterData);
-    };
-
-    Code39Base.prototype.addBase = function addBase () { };
-
-    return Code39Base;
-}(Encoding));
-
-export var Code39 = (function (Code39Base) {
-    function Code39 () {
-        Code39Base.apply(this, arguments);
     }
 
-    if ( Code39Base ) Code39.__proto__ = Code39Base;
-    Code39.prototype = Object.create( Code39Base && Code39Base.prototype );
-    Code39.prototype.constructor = Code39;
+    addBase() { }
+}
 
-    Code39.prototype.initProperties = function initProperties () {
-        Code39Base.prototype.initProperties.call(this);
+export class Code39 extends Code39Base {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             name: "Code 39",
@@ -126,85 +106,79 @@ export var Code39 = (function (Code39Base) {
                 START: { pattern: "bWbwBwBwb" }
             }
         });
-    };
+    }
 
-    Code39.prototype.initValue = function initValue (value, width, height) {
+    initValue(value, width, height) {
         this.width = width;
         this.height = height;
         this.value = value;
         this.dataLength = value.length;
         this.pattern = [];
         this.patternString = "";
-    };
-
-    Code39.prototype.prepareValues = function prepareValues () {
-        var this$1 = this;
+    }
 
-        var minBaseUnit = this.minBaseUnitLength;
-        var minRatio = this.minRatio;
-        var minHeight = Math.ceil(Math.max(0.15 * this.width, 24));
-        var baseUnit;
-        var ratio = this.maxRatio;
+    prepareValues() {
+        const minBaseUnit = this.minBaseUnitLength;
+        const minRatio = this.minRatio;
+        const minHeight = Math.ceil(Math.max(0.15 * this.width, 24));
+        let baseUnit;
+        let ratio = this.maxRatio;
 
         if (this.height < minHeight) {
-            throw new Error(("Insufficient height for Code39 encoding: the current height is " + (this.height) + "px and the minimum height is " + minHeight + "px."));
+            throw new Error(`Insufficient height for Code39 encoding: the current height is ${this.height}px and the minimum height is ${minHeight}px.`);
         }
 
         baseUnit = this.getBaseUnit(ratio);
 
         while (baseUnit < minBaseUnit && ratio > minRatio) {
             ratio = parseFloat((ratio - 0.1).toFixed(1));
-            baseUnit = this$1.getBaseUnit(ratio);
+            baseUnit = this.getBaseUnit(ratio);
         }
 
         if (baseUnit < minBaseUnit) {
-            var minWidth = Math.ceil(this.getBaseWidth(minRatio) * minBaseUnit);
-            throw new Error(("Insufficient width for Code39 encoding: the current width is " + (this.width) + "px and the minimum width for value \"" + (this.value) + "\" is " + minWidth + "px."));
+            let minWidth = Math.ceil(this.getBaseWidth(minRatio) * minBaseUnit);
+            throw new Error(`Insufficient width for Code39 encoding: the current width is ${this.width}px and the minimum width for value "${this.value}" is ${minWidth}px.`);
         }
 
         this.ratio = ratio;
         this.baseUnit = baseUnit;
         this.patternString = this.patternString.substring(0, this.patternString.length - 1);
         this.pattern = this.pattern.concat(this.patternString.replace(/ratio/g, ratio).split(this.splitCharacter));
-    };
+    }
 
-    Code39.prototype.getBaseUnit = function getBaseUnit (ratio) {
+    getBaseUnit(ratio) {
         return this.width / this.getBaseWidth(ratio);
-    };
+    }
 
-    Code39.prototype.getBaseWidth = function getBaseWidth (ratio) {
-        var characterLength = 3 * (ratio + 2);
+    getBaseWidth(ratio) {
+        const characterLength = 3 * (ratio + 2);
         return this.quietZoneLength + characterLength * (this.dataLength + 2) + this.gapWidth * (this.dataLength + 1);
-    };
+    }
 
-    Code39.prototype.addStart = function addStart () {
+    addStart() {
         this.addPattern(this.characterMap.START.pattern);
         this.addCharacterGap();
-    };
+    }
 
-    Code39.prototype.addBase = function addBase (character) {
+    addBase(character) {
         this.addPattern(character.pattern);
         this.addCharacterGap();
-    };
+    }
 
-    Code39.prototype.addStop = function addStop () {
+    addStop() {
         this.addPattern(this.characterMap.START.pattern);
-    };
-
-    Code39.prototype.addPattern = function addPattern (pattern) {
-        var this$1 = this;
+    }
 
-        for (var i = 0; i < pattern.length; i++) {
-            this$1.patternString += this$1.patternMappings[pattern.charAt(i)];
+    addPattern(pattern) {
+        for (let i = 0; i < pattern.length; i++) {
+            this.patternString += this.patternMappings[pattern.charAt(i)];
         }
-    };
+    }
 
-    Code39.prototype.addCharacterGap = function addCharacterGap () {
+    addCharacterGap() {
         this.patternString += this.gapWidth + this.splitCharacter;
-    };
-
-    return Code39;
-}(Code39Base));
+    }
+}
 
 setDefaultOptions(Code39, {
     addCheckSum: false

package/dist/es/barcode/encodings/code93-extended.js

@@ -2,41 +2,29 @@ import { Code93 } from './code93';
 import { Code39ExtendedBase } from './code39-extended';
 import deepExtend from '../../common/deep-extend';
 
-export var Code93Extended = (function (Code93) {
-    function Code93Extended () {
-        Code93.apply(this, arguments);
-    }
-
-    if ( Code93 ) Code93Extended.__proto__ = Code93;
-    Code93Extended.prototype = Object.create( Code93 && Code93.prototype );
-    Code93Extended.prototype.constructor = Code93Extended;
-
-    Code93Extended.prototype.initProperties = function initProperties () {
-        Code93.prototype.initProperties.call(this);
+export class Code93Extended extends Code93 {
+    initProperties() {
+        super.initProperties();
 
         deepExtend(this, Code39ExtendedBase, {
             name: "Code 93 extended",
             pushCheckSum: function() {
-                var this$1 = this;
-
-                var checkValues = this._getCheckValues();
-                var value;
+                const checkValues = this._getCheckValues();
+                let value;
 
                 this.checksum = checkValues.join("");
 
-                for (var i = 0; i < checkValues.length; i++) {
+                for (let i = 0; i < checkValues.length; i++) {
                     value = checkValues[i];
 
-                    if (this$1.shiftValuesAsciiCodes[value]) {
-                        this$1.addExtended(this$1.shiftValuesAsciiCodes[value]);
+                    if (this.shiftValuesAsciiCodes[value]) {
+                        this.addExtended(this.shiftValuesAsciiCodes[value]);
                     } else {
-                        var characterByValue = this$1._findCharacterByValue(value);
-                        this$1.addPattern(this$1.characterMap[characterByValue].pattern);
+                        const characterByValue = this._findCharacterByValue(value);
+                        this.addPattern(this.characterMap[characterByValue].pattern);
                     }
                 }
             }
         });
-    };
-
-    return Code93Extended;
-}(Code93));
+    }
+}

package/dist/es/barcode/encodings/code93.js

@@ -1,18 +1,10 @@
 import { Code39Base } from './code39';
 
-var extend = Object.assign;
+const extend = Object.assign;
 
-export var Code93 = (function (Code39Base) {
-    function Code93 () {
-        Code39Base.apply(this, arguments);
-    }
-
-    if ( Code39Base ) Code93.__proto__ = Code39Base;
-    Code93.prototype = Object.create( Code39Base && Code39Base.prototype );
-    Code93.prototype.constructor = Code93;
-
-    Code93.prototype.initProperties = function initProperties () {
-        Code39Base.prototype.initProperties.call(this);
+export class Code93 extends Code39Base {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             name: "Code 93",
@@ -71,79 +63,75 @@ export var Code93 = (function (Code39Base) {
                 TERMINATION_BAR: "1"
             }
         });
-    };
+    }
 
-    Code93.prototype.initValue = function initValue (value, width, height) {
+    initValue(value, width, height) {
         this.value = value;
         this.width = width;
         this.height = height;
         this.pattern = [];
         this.values = [];
         this.dataLength = value.length;
-    };
+    }
 
-    Code93.prototype.prepareValues = function prepareValues () {
-        var minHeight = Math.ceil(Math.max(0.15 * this.width, 24));
+    prepareValues() {
+        let minHeight = Math.ceil(Math.max(0.15 * this.width, 24));
 
         if (this.height < minHeight) {
-            throw new Error(("Insufficient height for Code93 encoding: the current height is " + (this.height) + "px, the minimum required height is " + minHeight + "px."));
+            throw new Error(`Insufficient height for Code93 encoding: the current height is ${this.height}px, the minimum required height is ${minHeight}px.`);
         }
 
         this.setBaseUnit();
 
         if (this.baseUnit < this.minBaseUnitLength) {
-            var minWidth = Math.ceil(this.minBaseUnitLength * (this.width / this.baseUnit));
-            throw new Error(("Insufficient width for Code93 encoding: the current width is " + (this.width) + "px and the minimum required width for value \"" + (this.value) + "\" is " + minWidth + "px."));
+            const minWidth = Math.ceil(this.minBaseUnitLength * (this.width / this.baseUnit));
+            throw new Error(`Insufficient width for Code93 encoding: the current width is ${this.width}px and the minimum required width for value "${this.value}" is ${minWidth}px.`);
         }
-    };
+    }
 
-    Code93.prototype.setBaseUnit = function setBaseUnit () {
-        var checkSumLength = 2;
+    setBaseUnit() {
+        const checkSumLength = 2;
 
         this.baseUnit = this.width / (9 * (this.dataLength + 2 + checkSumLength) + this.quietZoneLength + 1);
-    };
+    }
 
-    Code93.prototype.addStart = function addStart () {
-        var pattern = this.characterMap.START.pattern;
+    addStart() {
+        let pattern = this.characterMap.START.pattern;
         this.addPattern(pattern);
-    };
+    }
 
-    Code93.prototype.addStop = function addStop () {
+    addStop() {
         this.addStart();
         this.pattern.push(this.characterMap.TERMINATION_BAR);
-    };
+    }
 
-    Code93.prototype.addBase = function addBase (charData) {
+    addBase(charData) {
         this.addPattern(charData.pattern);
         this.values.push(charData.value);
-    };
-
-    Code93.prototype.pushCheckSum = function pushCheckSum () {
-        var this$1 = this;
+    }
 
-        var checkValues = this._getCheckValues();
-        var charData;
+    pushCheckSum() {
+        const checkValues = this._getCheckValues();
+        let charData;
 
         this.checksum = checkValues.join("");
 
-        for (var i = 0; i < checkValues.length; i++) {
-            charData = this$1.characterMap[this$1._findCharacterByValue(checkValues[i])];
-            this$1.addPattern(charData.pattern);
+        for (let i = 0; i < checkValues.length; i++) {
+            charData = this.characterMap[this._findCharacterByValue(checkValues[i])];
+            this.addPattern(charData.pattern);
         }
-    };
-
-    Code93.prototype._getCheckValues = function _getCheckValues () {
-        var this$1 = this;
+    }
 
-        var values = this.values;
-        var length = values.length;
-        var wightedSum = 0;
-        var cValue;
-        var kValue;
-        var idx;
+    _getCheckValues() {
+        const values = this.values;
+        const length = values.length;
+        let wightedSum = 0;
+        let cValue;
+        let kValue;
+        let idx;
 
         for (idx = length - 1; idx >= 0; idx--) {
-            wightedSum += this$1.weightedValue(values[idx], length - idx, this$1.cCheckSumTotal);
+            wightedSum += this.weightedValue(values[idx], length - idx, this.cCheckSumTotal);
         }
 
         cValue = wightedSum % this.checkSumMod;
@@ -151,37 +139,31 @@ export var Code93 = (function (Code39Base) {
         wightedSum = this.weightedValue(cValue, 1, this.kCheckSumTotal);
 
         for (idx = length - 1; idx >= 0; idx--) {
-            wightedSum += this$1.weightedValue(values[idx], length - idx + 1, this$1.kCheckSumTotal);
+            wightedSum += this.weightedValue(values[idx], length - idx + 1, this.kCheckSumTotal);
         }
 
         kValue = wightedSum % this.checkSumMod;
         return [cValue, kValue];
-    };
-
-    Code93.prototype._findCharacterByValue = function _findCharacterByValue (value) {
-        var this$1 = this;
+    }
 
-        for (var character in this$1.characterMap) {
-            if (this$1.characterMap[character].value === value) {
+    _findCharacterByValue(value) {
+        for (let character in this.characterMap) {
+            if (this.characterMap[character].value === value) {
                 return character;
             }
         }
-    };
+    }
 
-    Code93.prototype.weightedValue = function weightedValue (value, index, total) {
+    weightedValue(value, index, total) {
         return (index % total || total) * value;
-    };
-
-    Code93.prototype.addPattern = function addPattern (pattern) {
-        var this$1 = this;
+    }
 
-        var value;
+    addPattern(pattern) {
+        let value;
 
-        for (var i = 0; i < pattern.length; i++) {
+        for (let i = 0; i < pattern.length; i++) {
             value = parseInt(pattern.charAt(i), 10);
-            this$1.pattern.push(value);
+            this.pattern.push(value);
         }
-    };
-
-    return Code93;
-}(Code39Base));
+    }
+}

package/dist/es/barcode/encodings/ean13.js

@@ -1,18 +1,10 @@
 import { Encoding } from './encoding';
 
-var extend = Object.assign;
+const extend = Object.assign;
 
-export var Ean13 = (function (Encoding) {
-    function Ean13 () {
-        Encoding.apply(this, arguments);
-    }
-
-    if ( Encoding ) Ean13.__proto__ = Encoding;
-    Ean13.prototype = Object.create( Encoding && Encoding.prototype );
-    Ean13.prototype.constructor = Ean13;
-
-    Ean13.prototype.initProperties = function initProperties () {
-        Encoding.prototype.initProperties.call(this);
+export class Ean13 extends Encoding {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             name: "EAN 13",
@@ -45,10 +37,10 @@ export var Ean13 = (function (Encoding) {
                 middle: [1, 1, 1, 1, 1]
             }
         });
-    };
+    }
 
-    Ean13.prototype.initValue = function initValue (value, width, height) {
-        var valueAsString = String(value);
+    initValue(value, width, height) {
+        const valueAsString = String(value);
 
         if (valueAsString.length !== 12 || /\D/.test(valueAsString)) {
             throw new Error('The value of the "EAN13" encoding should be 12 symbols');
@@ -62,50 +54,46 @@ export var Ean13 = (function (Encoding) {
         this.leftKey = valueAsString[0];
         this.leftPart = valueAsString.substr(1, 6);
         this.rightPart = valueAsString.substr(7) + this.checksum;
-    };
+    }
 
-    Ean13.prototype.addData = function addData () {
+    addData() {
         this.addPieces(this.characterMap.start);
         this.addSide(this.leftPart, this.leftKey);
         this.addPieces(this.characterMap.middle);
         this.addSide(this.rightPart);
         this.addPieces(this.characterMap.start);
-    };
-
-    Ean13.prototype.addSide = function addSide (leftPart, key) {
-        var this$1 = this;
+    }
 
-        for (var i = 0; i < leftPart.length; i++) {
-            if (key && parseInt(this$1.keyTable[key].charAt(i), 10)) {
-                this$1.addPieces(Array.prototype.slice.call(this$1.characterMap.digits[leftPart.charAt(i)]).reverse(), true);
+    addSide(leftPart, key) {
+        for (let i = 0; i < leftPart.length; i++) {
+            if (key && parseInt(this.keyTable[key].charAt(i), 10)) {
+                this.addPieces(Array.prototype.slice.call(this.characterMap.digits[leftPart.charAt(i)]).reverse(), true);
             } else {
-                this$1.addPieces(this$1.characterMap.digits[leftPart.charAt(i)], true);
+                this.addPieces(this.characterMap.digits[leftPart.charAt(i)], true);
             }
         }
-    };
-
-    Ean13.prototype.addPieces = function addPieces (arrToAdd, limitedHeight) {
-        var this$1 = this;
+    }
 
-        for (var i = 0; i < arrToAdd.length; i++) {
+    addPieces(arrToAdd, limitedHeight) {
+        for (let i = 0; i < arrToAdd.length; i++) {
             if (limitedHeight) {
-                this$1.pattern.push({
+                this.pattern.push({
                     y1: 0,
-                    y2: this$1.options.height * 0.95,
+                    y2: this.options.height * 0.95,
                     width: arrToAdd[i]
                 });
             } else {
-                this$1.pattern.push(arrToAdd[i]);
+                this.pattern.push(arrToAdd[i]);
             }
         }
-    };
+    }
 
-    Ean13.prototype.calculateChecksum = function calculateChecksum () {
-        var odd = 0,
+    calculateChecksum() {
+        let odd = 0,
             even = 0,
             value = this.value.split("").reverse().join("");
 
-        for (var i = 0; i < value.length; i++) {
+        for (let i = 0; i < value.length; i++) {
             if (i % 2) {
                 even += parseInt(value.charAt(i), 10);
             } else {
@@ -113,10 +101,8 @@ export var Ean13 = (function (Encoding) {
             }
         }
 
-        var checksum = (10 - ((3 * odd + even) % 10)) % 10;
+        let checksum = (10 - ((3 * odd + even) % 10)) % 10;
 
         return checksum;
-    };
-
-    return Ean13;
-}(Encoding));
+    }
+}