@devexperts/dxcharts-lite 1.0.2 → 2.0.1

package/dist/chart/utils/canvas/canvas-drawing-functions.utils.js

@@ -3,4 +3,147 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-export function drawRoundedRect(e,i,o,l,a,n=4,r=!0,v=!1){e.save(),e.beginPath(),e.moveTo(i+n,o),e.lineTo(i+l-n,o),e.quadraticCurveTo(i+l,o,i+l,o+n),e.lineTo(i+l,o+a-n),e.quadraticCurveTo(i+l,o+a,i+l-n,o+a),e.lineTo(i+n,o+a),e.quadraticCurveTo(i,o+a,i,o+a-n),e.lineTo(i,o+n),e.quadraticCurveTo(i,o,i+n,o),e.closePath(),r&&e.fill(),v&&e.stroke(),e.restore()}export function drawPriceLabel(e,i,o,l,a,n,r,v,u,C,q=4,P=!0,m=!1){const s=C==="right"?v:-v,T=C==="right"?q:-q,f=q;e.save(),e.beginPath(),u?e.moveTo(n+T,r):e.moveTo(n,r),u?(e.lineTo(n+s-T,r),e.quadraticCurveTo(n+s,r,n+s,r-f),e.lineTo(n+s,o+f),e.quadraticCurveTo(n+s,o,n+s-T,o),e.lineTo(i+T,o)):(e.lineTo(n+s,r),e.lineTo(n+s,o),e.lineTo(i,o)),u?(e.quadraticCurveTo(i,o,i-T/3,o+f/3),e.lineTo(l+T/3,a-f/3),e.quadraticCurveTo(l,a,l+T/3,a+f/3),e.lineTo(n-T/3,r-f/3),e.quadraticCurveTo(n,r,n+T/3,r)):(e.lineTo(l,a),e.lineTo(n,r)),e.closePath(),P&&e.fill(),m&&e.stroke(),e.restore()}export function drawLine(e,i,o,l,a,n=1){e.save(),e.lineWidth=n,e.beginPath(),e.moveTo(i,o),e.lineTo(l,a),e.stroke(),e.closePath(),e.restore()}export function avoidAntialiasing(e,i){e.save(),e.lineWidth%2&&e.translate(.5,.5),i(),e.restore()}export function fillRect(e,i,o){const l=Math.min(i.x,o.x)+.5,a=Math.min(i.y,o.y),n=Math.abs(i.x-o.x),r=Math.abs(i.y-o.y);e.fillRect(l,a,n,r)}
+/**
+ * Draws a rounded rectangle on a canvas context
+ * @param {CanvasRenderingContext2D} ctx - The canvas context to draw on
+ * @param {number} x - The x-coordinate of the top-left corner of the rectangle
+ * @param {number} y - The y-coordinate of the top-left corner of the rectangle
+ * @param {number} width - The width of the rectangle
+ * @param {number} height - The height of the rectangle
+ * @param {number} [radius=4] - The radius of the corners of the rectangle
+ * @param {boolean} [fill=true] - Whether or not to fill the rectangle
+ * @param {boolean} [stroke=false] - Whether or not to stroke the rectangle
+ */
+export function drawRoundedRect(ctx, x, y, width, height, radius = 4, fill = true, stroke = false) {
+    ctx.save();
+    ctx.beginPath();
+    ctx.moveTo(x + radius, y);
+    ctx.lineTo(x + width - radius, y);
+    ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
+    ctx.lineTo(x + width, y + height - radius);
+    ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
+    ctx.lineTo(x + radius, y + height);
+    ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
+    ctx.lineTo(x, y + radius);
+    ctx.quadraticCurveTo(x, y, x + radius, y);
+    ctx.closePath();
+    if (fill) {
+        ctx.fill();
+    }
+    if (stroke) {
+        ctx.stroke();
+    }
+    ctx.restore();
+}
+/**
+ * Draws a price label on a canvas context.
+ * @param {CanvasRenderingContext2D} ctx - The canvas context to draw on.
+ * @param {number} x0 - The x-coordinate of the starting point of the label.
+ * @param {number} y0 - The y-coordinate of the starting point of the label.
+ * @param {number} x1 - The x-coordinate of the middle point of the label.
+ * @param {number} y1 - The y-coordinate of the middle point of the label.
+ * @param {number} x2 - The x-coordinate of the ending point of the label.
+ * @param {number} y2 - The y-coordinate of the ending point of the label.
+ * @param {number} _width - The width of the label.
+ * @param {boolean} rounded - Whether the label should have rounded corners.
+ * @param {string} align - The alignment of the label on the y-axis. Can be 'left' or 'right'.
+ * @param {number} radius - The radius of the rounded corners of the label.
+ * @param {boolean} fill - Whether the label should be filled with color.
+ * @param {boolean} stroke - Whether the label should have a stroke.
+ */
+export function drawPriceLabel(ctx, x0, y0, x1, y1, x2, y2, _width, rounded, align, radius = 4, fill = true, stroke = false) {
+    const width = align === 'right' ? _width : -_width;
+    const xRadius = align === 'right' ? radius : -radius;
+    const yRadius = radius;
+    ctx.save();
+    ctx.beginPath();
+    if (rounded) {
+        ctx.moveTo(x2 + xRadius, y2);
+    }
+    else {
+        ctx.moveTo(x2, y2);
+    }
+    // rect
+    if (rounded) {
+        ctx.lineTo(x2 + width - xRadius, y2);
+        ctx.quadraticCurveTo(x2 + width, y2, x2 + width, y2 - yRadius);
+        ctx.lineTo(x2 + width, y0 + yRadius);
+        ctx.quadraticCurveTo(x2 + width, y0, x2 + width - xRadius, y0);
+        ctx.lineTo(x0 + xRadius, y0);
+    }
+    else {
+        ctx.lineTo(x2 + width, y2);
+        ctx.lineTo(x2 + width, y0);
+        ctx.lineTo(x0, y0);
+    }
+    // triangle
+    if (rounded) {
+        ctx.quadraticCurveTo(x0, y0, x0 - xRadius / 3, y0 + yRadius / 3);
+        ctx.lineTo(x1 + xRadius / 3, y1 - yRadius / 3);
+        ctx.quadraticCurveTo(x1, y1, x1 + xRadius / 3, y1 + yRadius / 3);
+        ctx.lineTo(x2 - xRadius / 3, y2 - yRadius / 3);
+        ctx.quadraticCurveTo(x2, y2, x2 + xRadius / 3, y2);
+    }
+    else {
+        ctx.lineTo(x1, y1);
+        ctx.lineTo(x2, y2);
+    }
+    ctx.closePath();
+    if (fill) {
+        ctx.fill();
+    }
+    if (stroke) {
+        ctx.stroke();
+    }
+    ctx.restore();
+}
+/**
+ * Draws a line on a canvas context with the specified thickness.
+ *
+ * @param {CanvasRenderingContext2D} ctx - The canvas context to draw on.
+ * @param {number} x0 - The x-coordinate of the starting point of the line.
+ * @param {number} y0 - The y-coordinate of the starting point of the line.
+ * @param {number} x1 - The x-coordinate of the ending point of the line.
+ * @param {number} y1 - The y-coordinate of the ending point of the line.
+ * @param {number} [thickness=1] - The thickness of the line. Default is 1.
+ *
+ * @returns {void}
+ */
+export function drawLine(ctx, x0, y0, x1, y1, thickness = 1) {
+    ctx.save();
+    ctx.lineWidth = thickness;
+    ctx.beginPath();
+    ctx.moveTo(x0, y0);
+    ctx.lineTo(x1, y1);
+    ctx.stroke();
+    ctx.closePath();
+    ctx.restore();
+}
+/**
+ * Try to avoid anti-aliasing
+ */
+export function avoidAntialiasing(ctx, draw) {
+    // TODO rework, potentially make it one time per DRAW event
+    ctx.save();
+    if (ctx.lineWidth % 2) {
+        ctx.translate(0.5, 0.5);
+    }
+    draw();
+    ctx.restore();
+}
+/**
+ * Draws a filled rectangle on a canvas context.
+ *
+ * @param {CanvasRenderingContext2D} ctx - The canvas context to draw on.
+ * @param {{x: number, y: number}} a - The first point of the rectangle.
+ * @param {{x: number, y: number}} b - The second point of the rectangle.
+ * @returns {void}
+ 
+*/
+export function fillRect(ctx, a, b) {
+    const x = Math.min(a.x, b.x) + 0.5;
+    const y = Math.min(a.y, b.y);
+    const w = Math.abs(a.x - b.x);
+    const h = Math.abs(a.y - b.y);
+    ctx.fillRect(x, y, w, h);
+}

package/dist/chart/utils/canvas/canvas-font-measure-tool.utils.js

@@ -3,4 +3,54 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-const u={};export function calculateSymbolHeight(r,e){let t=u[r];return t!==void 0||(e.save(),e.font=r,t=e.measureText("M").width,u[r]=t,e.restore()),t}const a=new Map;export function calculateTextWidth(r,e,t){const n=t+r;let s=a.get(n);return s||(e.save(),e.font=t,s=e.measureText(r).width,a.set(n,s),e.restore()),s}
+/**
+ * Calculates max symbol height for provided font on canvas.
+ * @doc-tags tricky,chart-core,canvas
+ */
+const symbolHeightCache = {};
+/**
+ * Calculates the height of a symbol for a given font using a CanvasRenderingContext2D.
+ * @param {string} font - The font to calculate the symbol height for.
+ * @param {CanvasRenderingContext2D} ctx - The CanvasRenderingContext2D to use for the calculation.
+ * @returns {number} - The height of the symbol.
+ */
+export function calculateSymbolHeight(font, ctx) {
+    let result = symbolHeightCache[font];
+    if (result !== undefined) {
+        return result;
+    }
+    // Capital "M" width is very close to height, 90% approximation
+    ctx.save();
+    ctx.font = font;
+    result = ctx.measureText('M').width;
+    symbolHeightCache[font] = result;
+    ctx.restore();
+    return result;
+}
+/**
+ * Calculates text width in pixels for provided font on canvas.
+ * @param text
+ * @param ctx
+ * @param font
+ * @doc-tags tricky,chart-core,canvas
+ */
+const textWidthCache = new Map();
+/**
+ * Calculates the width of a given text using the provided font and canvas rendering context.
+ * @param {string} text - The text to calculate the width of.
+ * @param {CanvasRenderingContext2D} ctx - The canvas rendering context to use for measuring the text width.
+ * @param {string} font - The font to use for measuring the text width.
+ * @returns {number} - The width of the text in pixels.
+ */
+export function calculateTextWidth(text, ctx, font) {
+    const key = font + text;
+    let result = textWidthCache.get(key);
+    if (!result) {
+        ctx.save();
+        ctx.font = font;
+        result = ctx.measureText(text).width;
+        textWidthCache.set(key, result);
+        ctx.restore();
+    }
+    return result;
+}

package/dist/chart/utils/canvas/canvas-text-functions.utils.js

@@ -3,4 +3,159 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-import*as g from"color";export function prepareTextForFill(t,e){let n="";e.textStyle&&(e.textStyle.italic&&(n+="italic "),e.textStyle.bold&&(n+="bold ")),t.font=n+(e.textSize||12)+" "+(e.textFontFamily||"monospace"),t.fillStyle=e.textFill||"#FFFFFF",e.rtl?t.textAlign="right":t.textAlign="start"}export function getTextLineHeight(t){const e=t.font.match(/(\d+.)?\d+(px|pt)/gi);let n="10px";return e&&e.length&&(e[0].includes("pt")?n=+e[0].slice(0,e[0].indexOf("pt"))*96/72+"px":n=e[0]),parseInt(n,10)*1.33}export function getTextBounds(t,e,n){t.save(),prepareTextForFill(t,n);const i=Math.ceil(Math.max.apply(Math,e.map(o=>t.measureText(o).width))),l=getTextLineHeight(t),r=l*e.length;return t.restore(),[i,r,l]}export function getTextLines(t){return(t||"").split(/\r\n|\r|\n/)}export function drawText(t,e,n,i,l){t.save();const[r,,o]=getTextBounds(t,e,l);e.forEach((s,d)=>{var u,x,a;const h=t.measureText(s).width,f=c(n,r,h,(u=l.textAlign)!==null&&u!==void 0?u:"left");l.textStyle&&l.textStyle.underline&&underlineText(t,s,f,i+o*d,(x=l.textFill)!==null&&x!==void 0?x:"",(a=l.textSize)!==null&&a!==void 0?a:""),t.fillText(s,f,i+o*d)}),t.restore()}function c(t,e,n,i){switch(i){case"left":return t;case"right":return t+e-n;default:return t}}export function underlineText(t,e,n,i,l,r){t.save();const o=t.measureText(e).width,s=n,d=n+o,u=i+2,x=u;let a=parseInt(r,10)/15;a<1&&(a=1),t.beginPath(),t.strokeStyle=l,t.lineWidth=a,t.moveTo(s,u),t.lineTo(d,x),t.stroke(),t.restore()}export function getFontSizeInPx(t){return`${t}px`}export function getLabelTextColorByBackgroundColor(t,e,n){const i=g.rgb(t).array(),l=i[0],r=i[1],o=i[2];return(l*299+r*587+o*114)/1e3<128?e:n}
+import Color from 'color';
+/**
+ * Sets the font, fill style and text alignment of a canvas context based on the provided properties.
+ * @param {CanvasRenderingContext2D} ctx - The canvas context to modify.
+ * @param {CanvasTextProperties} properties - An object containing the properties to apply to the canvas context.
+ * @param {string} properties.textStyle - The style of the text. Can be 'italic', 'bold' or both.
+ * @param {number} properties.textSize - The size of the text in pixels.
+ * @param {string} properties.textFontFamily - The font family of the text.
+ * @param {string} properties.textFill - The fill style of the text.
+ * @param {boolean} properties.rtl - Whether the text should be aligned to the right or to the left.
+ */
+export function prepareTextForFill(ctx, properties) {
+    let textStyles = '';
+    if (properties.textStyle) {
+        properties.textStyle.italic && (textStyles += `italic `);
+        properties.textStyle.bold && (textStyles += `bold `);
+    }
+    ctx.font = textStyles + (properties.textSize || 12) + ' ' + (properties.textFontFamily || 'monospace');
+    ctx.fillStyle = properties.textFill || '#FFFFFF';
+    if (properties.rtl) {
+        ctx.textAlign = 'right';
+    }
+    else {
+        ctx.textAlign = 'start';
+    }
+}
+/**
+ * Calculates the line height of a text based on the font size of the provided CanvasRenderingContext2D.
+ * @param {CanvasRenderingContext2D} ctx - The CanvasRenderingContext2D object used to draw the text.
+ * @returns {number} The calculated line height of the text.
+ */
+export function getTextLineHeight(ctx) {
+    const textSizeMatch = ctx.font.match(/(\d+.)?\d+(px|pt)/gi);
+    let textSize = '10px';
+    if (textSizeMatch && textSizeMatch.length) {
+        if (textSizeMatch[0].includes('pt')) {
+            const ptSize = +textSizeMatch[0].slice(0, textSizeMatch[0].indexOf('pt'));
+            textSize = (ptSize * 96) / 72 + 'px';
+        }
+        else {
+            textSize = textSizeMatch[0];
+        }
+    }
+    return parseInt(textSize, 10) * 1.33; // Base Line Height in Project
+}
+/**
+ * Calculates text bounds [textWidth, textHeight, lineHeight]
+ * @param ctx
+ * @param lines
+ * @param properties
+ */
+export function getTextBounds(ctx, lines, properties) {
+    ctx.save();
+    prepareTextForFill(ctx, properties);
+    const textWidth = Math.ceil(Math.max.apply(Math, lines.map((text) => {
+        return ctx.measureText(text).width;
+    })));
+    const lineHeight = getTextLineHeight(ctx);
+    const textHeight = lineHeight * lines.length;
+    ctx.restore();
+    return [textWidth, textHeight, lineHeight];
+}
+/**
+ * Splits multiline text to array of lines
+ * @param text
+ */
+export function getTextLines(text) {
+    return (text || '').split(/\r\n|\r|\n/);
+}
+/**
+ * Draws multiple lines of text on a canvas context at a given position.
+ * @param {CanvasRenderingContext2D} ctx - The canvas context to draw on.
+ * @param {string[]} lines - An array of strings representing the lines of text to draw.
+ * @param {number} x - The x-coordinate of the starting position of the text.
+ * @param {number} y - The y-coordinate of the starting position of the text.
+ * @param {CanvasTextProperties} properties - An object containing properties for the text, such as font size, style, and alignment.
+ * @returns {void}
+ 
+*/
+export function drawText(ctx, lines, x, y, properties) {
+    ctx.save();
+    const [textWidth, , lineHeight] = getTextBounds(ctx, lines, properties);
+    lines.forEach((l, i) => {
+        var _a, _b, _c;
+        const lineWidth = ctx.measureText(l).width;
+        const alignedX = alignCanvasText(x, textWidth, lineWidth, (_a = properties.textAlign) !== null && _a !== void 0 ? _a : 'left');
+        if (properties.textStyle && properties.textStyle.underline) {
+            underlineText(ctx, l, alignedX, y + lineHeight * i, (_b = properties.textFill) !== null && _b !== void 0 ? _b : '', (_c = properties.textSize) !== null && _c !== void 0 ? _c : '');
+        }
+        ctx.fillText(l, alignedX, y + lineHeight * i);
+    });
+    ctx.restore();
+}
+/**
+ * Aligns canvas text based on the given parameters.
+ * @param {number} originalCoordinate - The original coordinate of the text.
+ * @param {number} maxWidth - The maximum width of the text.
+ * @param {number} textWidth - The width of the text.
+ * @param {CanvasTextAlignment} alignment - The alignment of the text.
+ * @returns {number} - The aligned coordinate of the text.
+ */
+function alignCanvasText(originalCoordinate, maxWidth, textWidth, alignment) {
+    switch (alignment) {
+        case 'left':
+            return originalCoordinate;
+        case 'right':
+            return originalCoordinate + maxWidth - textWidth;
+        default:
+            return originalCoordinate;
+    }
+}
+/**
+ * Draws an underline below the given text on a canvas context.
+ * @param {CanvasRenderingContext2D} ctx - The canvas context to draw on.
+ * @param {string} text - The text to underline.
+ * @param {number} x - The x-coordinate of the starting point of the text.
+ * @param {number} y - The y-coordinate of the starting point of the text.
+ * @param {string} color - The color of the underline.
+ * @param {string} textSize - The size of the text in pixels.
+ */
+export function underlineText(ctx, text, x, y, color, textSize) {
+    ctx.save();
+    const textWidth = ctx.measureText(text).width;
+    const startX = x;
+    const endX = x + textWidth;
+    const startY = y + 2; // shifts underline 2px lower than the text
+    const endY = startY;
+    let underlineHeight = parseInt(textSize, 10) / 15;
+    if (underlineHeight < 1) {
+        underlineHeight = 1;
+    }
+    ctx.beginPath();
+    ctx.strokeStyle = color;
+    ctx.lineWidth = underlineHeight;
+    ctx.moveTo(startX, startY);
+    ctx.lineTo(endX, endY);
+    ctx.stroke();
+    ctx.restore();
+}
+/**
+ * Returns a string with the font size in pixels.
+ *
+ * @param {number} fontSize - The font size in points.
+ * @returns {string} The font size in pixels as a string.
+ */
+export function getFontSizeInPx(fontSize) {
+    return `${fontSize}px`;
+}
+export function getLabelTextColorByBackgroundColor(bgColor, textColor, invertedTextColor) {
+    const rgb = Color.rgb(bgColor).array();
+    const r = rgb[0];
+    const g = rgb[1];
+    const b = rgb[2];
+    const yiq = (r * 299 + g * 587 + b * 114) / 1000;
+    return yiq < 128 ? textColor : invertedTextColor;
+}

package/dist/chart/utils/color.utils.js

@@ -3,4 +3,34 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-const c=/^(#)([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i,o=/^\s*(rgba?)\s*[(]\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*[\d.]+\s*)?[)]\s*$/i;function i(n){const t=c.exec(n)||o.exec(n);let s=[];return t&&(s=t.slice(2,5),t[1]==="#")?s.map(function(e){return parseInt(e,16)}):s}const r={};export function toRGBA(n,t){let s=r[n+t];if(!s){const e=i(n);s=e&&"rgba("+e.join(",")+","+t+")",r[n+t]=s}return s}
+const HEX_COLOR_REGEXP = /^(#)([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i;
+const RGB_COLOR_REGEXP = /^\s*(rgba?)\s*[(]\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*[\d.]+\s*)?[)]\s*$/i;
+function parseColor(color) {
+    const match = HEX_COLOR_REGEXP.exec(color) || RGB_COLOR_REGEXP.exec(color);
+    let colors = [];
+    if (match) {
+        colors = match.slice(2, 5);
+        if (match[1] === '#') {
+            return colors.map(function (s) {
+                return parseInt(s, 16);
+            });
+        }
+    }
+    return colors;
+}
+/**
+ *
+ * @param {String} color
+ * @param {Number} alpha
+ * @returns {String}
+ */
+const rgbaCache = {};
+export function toRGBA(color, alpha) {
+    let result = rgbaCache[color + alpha];
+    if (!result) {
+        const colors = parseColor(color);
+        result = colors && 'rgba(' + colors.join(',') + ',' + alpha + ')';
+        rgbaCache[color + alpha] = result;
+    }
+    return result;
+}

package/dist/chart/utils/device/browser.utils.js

@@ -3,4 +3,13 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-let e;export const isMobile=()=>(e||(e=!!navigator.userAgent.match(/Android|iPhone|Opera Mini/)||!1),e);
+let isMobileCache = undefined;
+/**
+ * @doc-tags utility,mobile
+ */
+export const isMobile = () => {
+    if (!isMobileCache) {
+        isMobileCache = !!navigator.userAgent.match(/Android|iPhone|Opera Mini/) || false;
+    }
+    return isMobileCache;
+};

package/dist/chart/utils/device/device-detector.utils.js

@@ -3,4 +3,27 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-export const deviceDetector=()=>{const e=/Mac|iPod|iPhone|iPad/i.test(navigator.userAgent),i=[/Android/i,/webOS/i,/BlackBerry/i,/Windows Phone/i].some(o=>navigator.userAgent.match(o));return e?"apple":i?"mobile":"other"},multiplyZoomByDevice=(e,t)=>e==="apple"||e==="mobile"?3:t;
+/**
+ * Detects the user device. Naive approach.
+ * @doc-tags tricky,mobile
+ */
+export const deviceDetector = () => {
+    const isApple = /Mac|iPod|iPhone|iPad/i.test(navigator.userAgent);
+    const mobileMatch = [/Android/i, /webOS/i, /BlackBerry/i, /Windows Phone/i];
+    const isMobile = mobileMatch.some(os => {
+        return navigator.userAgent.match(os);
+    });
+    if (isApple) {
+        return 'apple';
+    }
+    if (isMobile) {
+        return 'mobile';
+    }
+    return 'other';
+};
+export const multiplyZoomByDevice = (device, defaultValue) => {
+    if (device === 'apple' || device === 'mobile') {
+        return 3;
+    }
+    return defaultValue;
+};

package/dist/chart/utils/device/device-pixel-ratio.utils.js

@@ -3,4 +3,24 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-import{ceil as t,floor as n,round as d}from"../math.utils";export let dpr=window.devicePixelRatio;let o=window.matchMedia(`screen and (resolution: ${window.devicePixelRatio}dppx)`);const i=()=>{o.removeEventListener("change",i),dpr=window.devicePixelRatio,o=window.matchMedia(`screen and (resolution: ${window.devicePixelRatio}dppx)`),o.addEventListener("change",i)};o.addEventListener("change",i);export const getDPR=()=>dpr,roundToDPR=e=>d(dpr*e)/dpr,floorToDPR=e=>n(dpr*e)/dpr,ceilToDPR=e=>t(dpr*e)/dpr;
+import { ceil, floor, round } from '../math.utils';
+export let dpr = window.devicePixelRatio;
+// A media matcher which watches for changes in the device pixel ratio.
+let mediaMatcher = window.matchMedia(`screen and (resolution: ${window.devicePixelRatio}dppx)`);
+const updateDevicePixelRatio = () => {
+    mediaMatcher.removeEventListener('change', updateDevicePixelRatio);
+    dpr = window.devicePixelRatio;
+    mediaMatcher = window.matchMedia(`screen and (resolution: ${window.devicePixelRatio}dppx)`);
+    mediaMatcher.addEventListener('change', updateDevicePixelRatio);
+};
+mediaMatcher.addEventListener('change', updateDevicePixelRatio);
+export const getDPR = () => dpr;
+/**
+ * Rounds a given number according to the inverse of current DPR.
+ * For example, DPR = 2, num = 2, res => 2; DPR = 2, num = 2.5, res => 2.5; DPR = 2, num = 2.333, res => 2.5
+ * @param num
+ * @doc-tags chart-core,math,dpr
+ */
+export const roundToDPR = (num) => round(dpr * num) / dpr;
+export const floorToDPR = (num) => floor(dpr * num) / dpr;
+export const ceilToDPR = (num) => ceil(dpr * num) / dpr;

package/dist/chart/utils/device/touchpad.utils.js

@@ -3,4 +3,94 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-const o=/^((?!chrome|android).)*safari/i.test(navigator.userAgent),l=!!window.chrome;export const isFirefox=typeof InstallTrigger!="undefined";const d=navigator.platform.indexOf("Win")>-1;export const touchpadDetector=t=>{let i=!1;const{wheelDeltaY:a,wheelDeltaX:s}=t;if(a||s){let e;if(o)e=a===t.deltaY*-3||Math.abs(a+Math.sign(a))===Math.abs(Math.round(t.deltaY)*3)||Math.abs(a-Math.sign(a))===Math.abs(Math.round(t.deltaY)*3);else if(l){if(e=a+Math.sign(a)===t.deltaY*-3?a+Math.sign(a)===t.deltaY*-3:a===t.deltaY*-3,d){const n=Math.round(t.deltaY)===a||Math.abs(Math.round(t.deltaY)+Math.sign(t.deltaY))===Math.abs(a)||Math.abs(Math.round(t.deltaY)-Math.sign(t.deltaY))===Math.abs(a);e=Math.abs(a)===Math.abs(t.deltaY)||n}}else isFirefox?Math.abs(t.deltaY)>Math.abs(t.deltaX)?e=!1:e=s===t.deltaX*-3:e=a===t.deltaY*-3;e&&(i=!0)}else t.deltaMode===0&&(i=!0);return isFirefox&&t.deltaY>=16&&Math.abs(t.deltaY)%16===0&&(i=!1),t.ctrlKey&&(i=!0),i},getTouchpadSensitivity=t=>t.components.yAxis.type==="percent"?t.scale.zoomSensitivity/4:t.scale.zoomSensitivity;
+const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+//@ts-ignore
+const isChrome = !!window.chrome;
+//@ts-ignore
+export const isFirefox = typeof InstallTrigger !== 'undefined';
+const isWindows = navigator.platform.indexOf('Win') > -1;
+/**
+ * this function determines whether the event was triggered with the mouse or the touchpad
+ *
+ * This works because wheelDeltaY measures the physical distance that the actual hardware mouse wheel has travelled,
+ * while deltaY measures the amount of scrolling produced on screen.
+ * A conventional mouse typically has a much lower "scroll resolution" than a trackpad.
+ * The wheelDeltaY is exactly 3x the deltaY value(in most browsers)
+ * This function consist a lot of empiric if statements for some cases in different browsers and systems
+ * @param {WheelEvent} e
+ * @returns {boolean}
+ *
+ * @doc-tags chart-core, utility,
+ */
+export const touchpadDetector = (e) => {
+    let isTouchpad = false;
+    // this is essential prop to separate touchpad from mouse wheel
+    //@ts-ignore
+    const { wheelDeltaY, wheelDeltaX } = e;
+    if (wheelDeltaY || wheelDeltaX) {
+        let condition;
+        if (isSafari) {
+            condition =
+                wheelDeltaY === e.deltaY * -3 ||
+                    Math.abs(wheelDeltaY + Math.sign(wheelDeltaY)) === Math.abs(Math.round(e.deltaY) * 3) ||
+                    Math.abs(wheelDeltaY - Math.sign(wheelDeltaY)) === Math.abs(Math.round(e.deltaY) * 3);
+        }
+        else if (isChrome) {
+            condition =
+                wheelDeltaY + Math.sign(wheelDeltaY) === e.deltaY * -3
+                    ? wheelDeltaY + Math.sign(wheelDeltaY) === e.deltaY * -3
+                    : wheelDeltaY === e.deltaY * -3;
+            // Chrome windows case
+            if (isWindows) {
+                const diapazoneCondition = Math.round(e.deltaY) === wheelDeltaY ||
+                    Math.abs(Math.round(e.deltaY) + Math.sign(e.deltaY)) === Math.abs(wheelDeltaY) ||
+                    Math.abs(Math.round(e.deltaY) - Math.sign(e.deltaY)) === Math.abs(wheelDeltaY);
+                const equalCondition = Math.abs(wheelDeltaY) === Math.abs(e.deltaY);
+                condition = equalCondition || diapazoneCondition;
+            }
+        }
+        else if (isFirefox) {
+            if (Math.abs(e.deltaY) > Math.abs(e.deltaX)) {
+                // disable vertical scroll in Firefox bcs it is unstable
+                condition = false;
+            }
+            else {
+                condition = wheelDeltaX === e.deltaX * -3;
+            }
+        }
+        else {
+            // basic rule
+            condition = wheelDeltaY === e.deltaY * -3;
+        }
+        if (condition) {
+            isTouchpad = true;
+        }
+    }
+    else if (e.deltaMode === 0) {
+        isTouchpad = true;
+    }
+    // Firefox for some reason is not obey to rules above
+    // so we just this trigger this as mouse wheel event
+    if (isFirefox && e.deltaY >= 16 && Math.abs(e.deltaY) % 16 === 0) {
+        isTouchpad = false;
+    }
+    // it is necessary to correctly recognize pinch on touchpad
+    // could be emulated mouse wheel + ctrl key BE AWARE!!
+    if (e.ctrlKey) {
+        isTouchpad = true;
+    }
+    return isTouchpad;
+};
+/**
+ * this function returns different ящщь sensitivity for the percent axis and the others
+ * @param config
+ * @param isTouchpad
+ * @returns {number}
+ *
+ * @doc-tags chart-core, zoom
+ */
+export const getTouchpadSensitivity = (config) => {
+    const isPercentAxisType = config.components.yAxis.type === 'percent';
+    const zoomSensitivity = isPercentAxisType ? config.scale.zoomSensitivity / 4 : config.scale.zoomSensitivity;
+    return zoomSensitivity;
+};

package/dist/chart/utils/dom.utils.js

@@ -3,4 +3,18 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-export function subscribeListener(n,r,i,t){return n.addEventListener(i,r,t),function(){n.removeEventListener(i,r,t)}}
+/**
+ * @param {Element} element
+ * @param {function} listener
+ * @param {string} eventType
+ * @param {boolean?} useCapture
+ * @return {Function}
+ */
+export function subscribeListener(element, listener, eventType, useCapture) {
+    // @ts-ignore
+    element.addEventListener(eventType, listener, useCapture);
+    return function () {
+        // @ts-ignore
+        element.removeEventListener(eventType, listener, useCapture);
+    };
+}

package/dist/chart/utils/function.utils.js

@@ -3,4 +3,19 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-export function clearerSafe(n){return function(){n.forEach(t=>typeof t=="function"&&t()),n.length=0}}export function identity(n){return n}export function notEmpty(n){return n!=null}export const constVoid=()=>{};export function nonNullableTypeGuard(n){return n!=null}
+export function clearerSafe(arr) {
+    return function doClearSafe() {
+        arr.forEach(f => typeof f === 'function' && f());
+        arr.length = 0;
+    };
+}
+export function identity(x) {
+    return x;
+}
+export function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+export const constVoid = () => void 0;
+export function nonNullableTypeGuard(x) {
+    return x !== undefined && x !== null;
+}

package/dist/chart/utils/linkedList.utils.d.ts

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export declare class ListNode<T> {
+    data: T;
+    next: ListNode<T> | null;
+    constructor(data: T);
+}
+/**
+ * Implementation of Linked list data structure.
+ * @param _head
+ */
+export declare class LinkedList<T> {
+    private _head;
+    private _tail;
+    private length;
+    constructor(head?: ListNode<T>);
+    insertAtEnd(data: T): ListNode<T>;
+    insertAt(position: number, data: T): ListNode<T> | null;
+    removeAt(position: number): ListNode<T> | null;
+    getNodePosition(node: ListNode<T>): number;
+    size(): number;
+    get head(): ListNode<T> | null;
+    get tail(): ListNode<T> | null;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+}