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

package/dist/es/stock/stock-chart.js

@@ -5,22 +5,15 @@ import { DEFAULT_WIDTH } from '../common/constants';
 import { addClass, deepExtend, elementSize, grep, setDefaultOptions } from '../common';
 import { NAVIGATOR_AXIS, NAVIGATOR_PANE } from './constants';
 
-var AUTO_CATEGORY_WIDTH = 28;
+const AUTO_CATEGORY_WIDTH = 28;
 
-var StockChart = (function (Chart) {
-    function StockChart () {
-        Chart.apply(this, arguments);
-    }
-
-    if ( Chart ) StockChart.__proto__ = Chart;
-    StockChart.prototype = Object.create( Chart && Chart.prototype );
-    StockChart.prototype.constructor = StockChart;
+class StockChart extends Chart {
 
-    StockChart.prototype.applyDefaults = function applyDefaults (options, themeOptions) {
-        var width = elementSize(this.element).width || DEFAULT_WIDTH;
-        var theme = themeOptions;
+    applyDefaults(options, themeOptions) {
+        const width = elementSize(this.element).width || DEFAULT_WIDTH;
+        let theme = themeOptions;
 
-        var stockDefaults = {
+        const stockDefaults = {
             seriesDefaults: {
                 categoryField: options.dateField
             },
@@ -47,52 +40,52 @@ var StockChart = (function (Chart) {
 
         Navigator.setup(options, theme);
 
-        Chart.prototype.applyDefaults.call(this, options, theme);
-    };
+        super.applyDefaults(options, theme);
+    }
 
-    StockChart.prototype._setElementClass = function _setElementClass (element) {
+    _setElementClass(element) {
         addClass(element, 'k-chart k-stockchart');
-    };
+    }
 
-    StockChart.prototype.setOptions = function setOptions (options) {
+    setOptions(options) {
         this.destroyNavigator();
-        Chart.prototype.setOptions.call(this, options);
-    };
+        super.setOptions(options);
+    }
 
-    StockChart.prototype.noTransitionsRedraw = function noTransitionsRedraw () {
-        var transitions = this.options.transitions;
+    noTransitionsRedraw() {
+        const transitions = this.options.transitions;
 
         this.options.transitions = false;
         this._fullRedraw();
         this.options.transitions = transitions;
-    };
+    }
 
-    StockChart.prototype._resize = function _resize () {
+    _resize() {
         this.noTransitionsRedraw();
-    };
+    }
 
-    StockChart.prototype._redraw = function _redraw () {
-        var navigator = this.navigator;
+    _redraw() {
+        const navigator = this.navigator;
 
         if (!this._dirty() && navigator && navigator.options.partialRedraw) {
             navigator.redrawSlaves();
         } else {
             this._fullRedraw();
         }
-    };
+    }
 
-    StockChart.prototype._dirty = function _dirty () {
-        var options = this.options;
-        var series = [].concat(options.series, options.navigator.series);
-        var seriesCount = grep(series, function(s) { return s && s.visible; }).length;
-        var dirty = this._seriesCount !== seriesCount;
+    _dirty() {
+        const options = this.options;
+        const series = [].concat(options.series, options.navigator.series);
+        const seriesCount = grep(series, function(s) { return s && s.visible; }).length;
+        const dirty = this._seriesCount !== seriesCount;
         this._seriesCount = seriesCount;
 
         return dirty;
-    };
+    }
 
-    StockChart.prototype._fullRedraw = function _fullRedraw () {
-        var navigator = this.navigator;
+    _fullRedraw() {
+        let navigator = this.navigator;
 
         if (!navigator) {
             navigator = this.navigator = new Navigator(this);
@@ -102,70 +95,68 @@ var StockChart = (function (Chart) {
         navigator.clean();
         navigator.setRange();
 
-        Chart.prototype._redraw.call(this);
+        super._redraw();
 
         navigator.initSelection();
-    };
+    }
 
-    StockChart.prototype._trackSharedTooltip = function _trackSharedTooltip (coords) {
-        var plotArea = this._plotArea;
-        var pane = plotArea.paneByPoint(coords);
+    _trackSharedTooltip(coords) {
+        const plotArea = this._plotArea;
+        const pane = plotArea.paneByPoint(coords);
 
         if (pane && pane.options.name === NAVIGATOR_PANE) {
             this._unsetActivePoint();
         } else {
-            Chart.prototype._trackSharedTooltip.call(this, coords);
+            super._trackSharedTooltip(coords);
         }
-    };
+    }
 
-    StockChart.prototype.bindCategories = function bindCategories () {
-        Chart.prototype.bindCategories.call(this);
+    bindCategories() {
+        super.bindCategories();
         this.copyNavigatorCategories();
-    };
+    }
 
-    StockChart.prototype.copyNavigatorCategories = function copyNavigatorCategories () {
-        var definitions = [].concat(this.options.categoryAxis);
-        var categories;
+    copyNavigatorCategories() {
+        const definitions = [].concat(this.options.categoryAxis);
+        let categories;
 
-        for (var axisIx = 0; axisIx < definitions.length; axisIx++) {
-            var axis = definitions[axisIx];
+        for (let axisIx = 0; axisIx < definitions.length; axisIx++) {
+            const axis = definitions[axisIx];
             if (axis.name === NAVIGATOR_AXIS) {
                 categories = axis.categories;
             } else if (categories && axis.pane === NAVIGATOR_PANE) {
                 axis.categories = categories;
             }
         }
-    };
+    }
 
-    StockChart.prototype.destroyNavigator = function destroyNavigator () {
+    destroyNavigator() {
         if (this.navigator) {
             this.navigator.destroy();
             this.navigator = null;
         }
-    };
+    }
 
-    StockChart.prototype.destroy = function destroy () {
+    destroy() {
         this.destroyNavigator();
-        Chart.prototype.destroy.call(this);
-    };
+        super.destroy();
+    }
 
-    StockChart.prototype._stopChartHandlers = function _stopChartHandlers (e) {
-        var coords = this._eventCoordinates(e);
-        var pane = this._plotArea.paneByPoint(coords);
+    _stopChartHandlers(e) {
+        const coords = this._eventCoordinates(e);
+        const pane = this._plotArea.paneByPoint(coords);
 
-        return Chart.prototype._stopChartHandlers.call(this, e) || (pane && pane.options.name === NAVIGATOR_PANE);
-    };
+        return super._stopChartHandlers(e) || (pane && pane.options.name === NAVIGATOR_PANE);
+    }
 
-    StockChart.prototype._toggleDragZoomEvents = function _toggleDragZoomEvents () {
+    _toggleDragZoomEvents() {
         if (!this._dragZoomEnabled) {
             this.element.style.touchAction = "none";
 
             this._dragZoomEnabled = true;
         }
-    };
-
-    return StockChart;
-}(Chart));
+    }
+}
 
 setDefaultOptions(StockChart, {
     dateField: "date",

package/dist/es2015/chart/legend/legend-item.js

@@ -122,7 +122,7 @@ class LegendItem extends BoxElement {
                 if (typeof pattern === 'function') {
                     pattern = pattern(options.series);
                 }
-                pattern = structuredClone(pattern);
+                pattern = Object.assign({}, pattern);
                 this._reduceSize(pattern, 'gap');
                 this._reduceSize(pattern, 'width');
                 this._reduceSize(pattern, 'radius');

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

@@ -5,7 +5,7 @@ import {
     getVersion,
     getDataCodewordsCount,
     getDataString
-} from '../encoding';
+} from '../utils/index';
 
 export class IsoEncoder extends Class {
     getEncodingResult(inputString, errorCorrectionLevel) {

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

@@ -3,7 +3,7 @@ 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';
+import { getVersion } from '../utils/index';
 
 const BYTE = "byte";
 

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

@@ -6,12 +6,8 @@ import { FreeCellVisitor } from './free-cell-visitor';
 import { IsoEncoder } from './encoders/iso-encoder';
 import { Utf8Encoder } from './encoders/utf8-encoder';
 import { VersionsCodewordsInformation } from './version-codewords';
-import { DataModeInstances } from './data-modes/data-mode-instances';
 
 let terminator = "0000",
-    NUMERIC = "numeric",
-    ALPHA_NUMERIC = "alphanumeric",
-    BYTE = "byte",
     powersOfTwo = { "1": 0 },
     powersOfTwoResult = { "0": 1 },
     irregularAlignmentPatternsStartDistance = {
@@ -38,21 +34,9 @@ let terminator = "0000",
         (row, column) => { return ((row * column) % 2) + ((row * column) % 3) === 0; },
         (row, column) => { return (((row * column) % 2) + ((row * column) % 3)) % 2 === 0; },
         (row, column) => { return (((row + column) % 2) + ((row * column) % 3)) % 2 === 0; }
-    ],
-    /* eslint-enable no-unused-vars */
-    /* eslint-enable arrow-body-style */
-    numberRegex = /^\d+/,
-    alphaPattern = "A-Z0-9 $%*+./:-",
-    alphaExclusiveSet = "A-Z $%*+./:-",
-    alphaRegex = new RegExp("^[" + alphaExclusiveSet + "]+"),
-    alphaNumericRegex = new RegExp("^[" + alphaPattern + "]+"),
-    byteRegex = new RegExp("^[^" + alphaPattern + "]+"),
-    initMinNumericBeforeAlpha = 8,
-    initMinNumericBeforeByte = 5,
-    initMinAlphaBeforeByte = 8,
-    minNumericBeforeAlpha = 17,
-    minNumericBeforeByte = 9,
-    minAlphaBeforeByte = 16;
+    ];
+/* eslint-enable no-unused-vars */
+/* eslint-enable arrow-body-style */
 
 export const generatorPolynomials = [[1, 0], [1, 25, 0]];
 
@@ -252,114 +236,6 @@ export function getBlocks(dataStream, versionCodewordsInformation) {
     return [dataBlocks, errorBlocks];
 }
 
-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
-    };
-}
-
-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;
-}
-
-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);
-}
-
-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;
-}
-
-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;
-}
-
 //fix case all zeros
 export function encodeFormatInformation(format) {
     let formatNumber = toDecimal(format),

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