@gravity-ui/chartkit 0.9.1 → 0.10.1

package/build/plugins/highcharts/renderer/helpers/highcharts/highcharts.js

@@ -0,0 +1,346 @@
+/* eslint-disable complexity */
+import Highcharts from 'highcharts';
+import get from 'lodash/get';
+import { i18n } from '../../../../../i18n';
+import { hideFixedTooltip, getTooltipPositioner, handleScroll, synchronizeTooltipTablesCellsWidth, } from '../config/config';
+import { TOOLTIP_ROW_CLASS_NAME, TOOLTIP_LIST_CLASS_NAME, TOOLTIP_FOOTER_CLASS_NAME, TOOLTIP_CONTAINER_CLASS_NAME, TOOLTIP_ROW_NAME_CLASS_NANE, } from '../tooltip';
+import colors from './colors';
+import { calculateClosestPointManually } from './utils';
+function formatQ(timestamp) {
+    const date = new Date(timestamp);
+    const month = date.getUTCMonth() + 1;
+    return 'Q' + Math.ceil(month / 3);
+}
+const REST_SECTION_HEIGHT = 25;
+Highcharts.dateFormats = {
+    Q: formatQ,
+    q: formatQ,
+    quarter: formatQ,
+};
+Math.easeInQuint = function (pos) {
+    return Math.pow(pos, 5);
+};
+Highcharts.setOptions({
+    colors: colors,
+    credits: {
+        enabled: false,
+    },
+    chart: {
+        animation: false,
+        displayErrors: false,
+        resetZoomButton: {
+            relativeTo: 'chart',
+            theme: {
+                width: 16,
+                height: 16,
+                'text-align': 'center',
+                opacity: '0.8',
+                cursor: 'pointer',
+            },
+            position: {
+                y: 30,
+            },
+        },
+    },
+    title: {
+        text: '',
+        style: {
+            fontSize: '15px',
+            fontWeight: 'bold',
+        },
+    },
+    legend: {
+        enabled: true,
+        itemStyle: {
+            fontWeight: 'normal',
+        },
+        navigation: {
+            animation: false,
+        },
+    },
+    tooltip: {
+        borderRadius: '0px',
+        borderWidth: 0,
+        useHTML: true,
+        hideDelay: 0,
+        animation: false,
+        shadow: false,
+    },
+    xAxis: {
+        gridLineColor: '#dbdbdb',
+        gridLineWidth: 1,
+        lineColor: '#dbdbdb',
+    },
+    yAxis: {
+        title: {
+            text: null,
+        },
+    },
+    plotOptions: {
+        series: {
+            animation: false,
+            shadow: false,
+            connectNulls: false,
+            dataGrouping: {
+                enabled: false,
+            },
+            states: {
+                normal: {
+                    animation: false,
+                },
+                hover: {
+                    animation: false,
+                },
+                inactive: {
+                    animation: false,
+                    opacity: 0.7,
+                },
+            },
+            marker: {
+                states: {
+                    hover: {
+                        animation: false,
+                    },
+                    normal: {
+                        animation: false,
+                    },
+                },
+            },
+        },
+    },
+});
+function initHighcharts({ isMobile }) {
+    Highcharts.setOptions({
+        lang: {
+            resetZoom: '⟲',
+            resetZoomTitle: i18n('highcharts', 'reset-zoom-title'),
+            months: [
+                i18n('highcharts', 'January'),
+                i18n('highcharts', 'February'),
+                i18n('highcharts', 'March'),
+                i18n('highcharts', 'April'),
+                i18n('highcharts', 'May'),
+                i18n('highcharts', 'June'),
+                i18n('highcharts', 'July'),
+                i18n('highcharts', 'August'),
+                i18n('highcharts', 'September'),
+                i18n('highcharts', 'October'),
+                i18n('highcharts', 'November'),
+                i18n('highcharts', 'December'),
+            ],
+            shortMonths: [
+                i18n('highcharts', 'Jan'),
+                i18n('highcharts', 'Feb'),
+                i18n('highcharts', 'Mar'),
+                i18n('highcharts', 'Apr'),
+                i18n('highcharts', 'May'),
+                i18n('highcharts', 'Jun'),
+                i18n('highcharts', 'Jul'),
+                i18n('highcharts', 'Aug'),
+                i18n('highcharts', 'Sep'),
+                i18n('highcharts', 'Oct'),
+                i18n('highcharts', 'Nov'),
+                i18n('highcharts', 'Dec'),
+            ],
+            weekdays: [
+                i18n('highcharts', 'Sun'),
+                i18n('highcharts', 'Mon'),
+                i18n('highcharts', 'Tue'),
+                i18n('highcharts', 'Wed'),
+                i18n('highcharts', 'Thu'),
+                i18n('highcharts', 'Fri'),
+                i18n('highcharts', 'Sat'),
+            ],
+            decimalPoint: i18n('highcharts', 'decimal-point'),
+            thousandsSep: i18n('highcharts', 'thousands-sep'),
+        },
+    });
+    // https://github.com/highcharts/highcharts/issues/11494
+    (function (H) {
+        H.wrap(H.Tooltip.prototype, 'getLabel', function (proceed, ...rest) {
+            const t = proceed.apply(this, rest);
+            if (this.container) {
+                H.css(this.container, {
+                    zIndex: 100001,
+                });
+            }
+            return t;
+        });
+    })(Highcharts);
+    Highcharts.wrap(Highcharts.Chart.prototype, 'redraw', function (proceed, ...rest) {
+        if (this.tooltip.fixed) {
+            hideFixedTooltip(this.tooltip, isMobile);
+        }
+        proceed.apply(this, rest);
+        if (this.afterRedrawCallback) {
+            this.afterRedrawCallback();
+            delete this.afterRedrawCallback;
+        }
+    });
+    Highcharts.wrap(Highcharts.Chart.prototype, 'destroy', function (proceed, ...rest) {
+        if (this.tooltip.clickOutsideHandler) {
+            window.document.removeEventListener('click', this.tooltip.clickOutsideHandler);
+        }
+        if (this.tooltip.fixed) {
+            hideFixedTooltip(this.tooltip, isMobile);
+        }
+        proceed.apply(this, ...rest);
+    });
+    Highcharts.wrap(Highcharts.Point.prototype, 'setState', function (proceed, ...rest) {
+        if (!this.series.chart.tooltip.fixed) {
+            proceed.apply(this, rest);
+        }
+    });
+    Highcharts.wrap(Highcharts.Tooltip.prototype, 'init', function (proceed, ...rest) {
+        this.orientationChangeHandler = () => {
+            if (isMobile) {
+                const resizeHandler = () => {
+                    this.update({
+                        positioner: getTooltipPositioner(isMobile),
+                    });
+                    if (this.chart.hoverPoints) {
+                        this.chart.hoverPoints.forEach((point) => {
+                            point.setState('');
+                        });
+                        delete this.chart.hoverPoints;
+                    }
+                    if (this.chart.hoverPoint) {
+                        this.chart.hoverPoint.setState('');
+                        delete this.chart.hoverPoint;
+                    }
+                    window.removeEventListener('resize', resizeHandler);
+                };
+                window.addEventListener('resize', resizeHandler);
+            }
+        };
+        window.addEventListener('orientationchange', this.orientationChangeHandler);
+        proceed.apply(this, rest);
+    });
+    Highcharts.wrap(Highcharts.Tooltip.prototype, 'destroy', function (proceed, ...rest) {
+        window.removeEventListener('orientationchange', this.orientationChangeHandler);
+        window.removeEventListener('scroll', this.scrollHandler);
+        proceed.apply(this, rest);
+    });
+    Highcharts.wrap(Highcharts.Tooltip.prototype, 'hide', function (proceed, ...rest) {
+        if (this.lastVisibleRowIndex) {
+            this.lastVisibleRowIndex = null;
+        }
+        if (this.scrollHandler && !this.fixed) {
+            window.removeEventListener('scroll', this.scrollHandler);
+            this.scrollHandler = null;
+            this.chart.topPosition = null;
+        }
+        if (!this.fixed) {
+            proceed.apply(this, rest);
+        }
+    });
+    Highcharts.wrap(Highcharts.Tooltip.prototype, 'hideFixedTooltip', function () {
+        if (this.fixed) {
+            hideFixedTooltip(this, isMobile);
+        }
+    });
+    Highcharts.wrap(Highcharts.Tooltip.prototype, 'refresh', function (proceed, points, ...rest) {
+        const isNonBodyScroll = get(this.chart, 'userOptions._config.nonBodyScroll');
+        const maxTooltipLines = get(this.chart, 'userOptions._config.maxTooltipLines');
+        const chartType = this.chart.options.chart.type;
+        if (isNonBodyScroll && !this.scrollHandler) {
+            this.scrollHandler = handleScroll.bind(this);
+            this.chart.topPosition = this.chart.container.getBoundingClientRect().top;
+            window.addEventListener('scroll', this.scrollHandler, true);
+        }
+        if (this.chart.pointsForInitialRefresh) {
+            delete this.chart.pointsForInitialRefresh;
+        }
+        if (chartType === 'map' && !this.fixed) {
+            proceed.apply(this, [points, ...rest]);
+        }
+        const isFixation = rest[1];
+        if ((!this.fixed || isFixation) && points) {
+            if (isFixation) {
+                this.lastVisibleRowIndex = null;
+            }
+            proceed.apply(this, [points, ...rest]);
+            if (chartType === 'timeline') {
+                return false;
+            }
+            if (this.container) {
+                synchronizeTooltipTablesCellsWidth(this.container, isMobile);
+            }
+            if (isFixation) {
+                const rowNames = this.container.querySelectorAll(`.${TOOLTIP_ROW_NAME_CLASS_NANE}`);
+                for (let i = 0; i < rowNames.length; i++) {
+                    const rowNameNode = rowNames[i];
+                    if (rowNameNode.scrollWidth > rowNameNode.clientWidth) {
+                        const rowNameNodeText = rowNameNode.innerText;
+                        rowNameNode.setAttribute('title', rowNameNodeText);
+                    }
+                }
+                return false;
+            }
+        }
+        if (this.container && !this.fixed && !this.lastVisibleRowIndex) {
+            const tooltipNode = this.container.querySelector(`.${TOOLTIP_CONTAINER_CLASS_NAME}`);
+            if (!tooltipNode) {
+                return false;
+            }
+            const hasScroll = tooltipNode.scrollHeight > tooltipNode.clientHeight;
+            const moreThanMaxLines = maxTooltipLines && points.length > maxTooltipLines;
+            if (hasScroll || moreThanMaxLines) {
+                const footerNode = tooltipNode.querySelector(`.${TOOLTIP_FOOTER_CLASS_NAME}`);
+                const { top, height } = tooltipNode.getBoundingClientRect();
+                const footerNodeHeight = footerNode ? footerNode.clientHeight : 0;
+                const bottomPadding = parseFloat(window.getComputedStyle(tooltipNode, null).getPropertyValue('padding-bottom'), 10);
+                const containerBottomEdge = top + height;
+                const rows = tooltipNode.querySelectorAll(`.${TOOLTIP_LIST_CLASS_NAME} .${TOOLTIP_ROW_CLASS_NAME}`);
+                let lastVisibleRowIndex = null;
+                const selectedSeriesIndex = this.chart.hoverPoints.indexOf(this.chart.hoverPoint);
+                const rowForSelectedSeriesHeight = selectedSeriesIndex >= 0
+                    ? rows[selectedSeriesIndex].getBoundingClientRect().height
+                    : 0;
+                if (maxTooltipLines && rows.length > maxTooltipLines) {
+                    lastVisibleRowIndex = maxTooltipLines - 1;
+                }
+                else {
+                    for (let i = rows.length - 1; i > 0; i--) {
+                        const row = rows[i];
+                        const { top: rowTop, height: rowHeight } = row.getBoundingClientRect();
+                        const rowBottomEdge = rowTop + rowHeight;
+                        const containerBottomEdgeWithPadding = containerBottomEdge - bottomPadding;
+                        const margin = REST_SECTION_HEIGHT + footerNodeHeight + rowForSelectedSeriesHeight;
+                        const rowBottomEdgeWithMargin = rowBottomEdge + margin;
+                        if (rowBottomEdgeWithMargin <= containerBottomEdgeWithPadding) {
+                            lastVisibleRowIndex = i;
+                            break;
+                        }
+                    }
+                }
+                if (lastVisibleRowIndex) {
+                    this.lastVisibleRowIndex = lastVisibleRowIndex;
+                    this.refresh(points, ...rest);
+                }
+            }
+        }
+    });
+    Highcharts.wrap(Highcharts.Axis.prototype, 'getClosest', function (proceed, ...rest) {
+        const userOptions = this.userOptions || {};
+        if (userOptions.calcClosestPointManually) {
+            return calculateClosestPointManually.apply(this);
+        }
+        else {
+            return proceed.apply(this, rest);
+        }
+    });
+}
+function initHighchartsMap() {
+    Highcharts.wrap(Highcharts.ColorAxis.prototype, 'drawCrosshair', function (proceed, ...rest) {
+        if (!this.chart.tooltip.fixed) {
+            proceed.apply(this, rest);
+        }
+    });
+    Highcharts.wrap(Highcharts.ColorAxis.prototype, 'hideCrosshair', function (proceed, ...rest) {
+        if (!this.chart.tooltip.fixed) {
+            proceed.apply(this, rest);
+        }
+    });
+}
+export { initHighcharts, initHighchartsMap };

package/build/plugins/highcharts/renderer/helpers/highcharts/utils/calcucalteClosestPointManually.d.ts

@@ -0,0 +1 @@
+export declare function calculateClosestPointManually(this: any): number | undefined;

package/build/plugins/highcharts/renderer/helpers/highcharts/utils/calcucalteClosestPointManually.js

@@ -0,0 +1,19 @@
+export function calculateClosestPointManually() {
+    const series = this.series;
+    const xValues = series.reduce((values, currSeries) => {
+        return values.concat(currSeries.processedXData);
+    }, []);
+    xValues.sort((a, b) => b - a);
+    let closestPointRange;
+    xValues.forEach((xValue, index) => {
+        const nextXValue = xValues[index + 1];
+        if (nextXValue) {
+            const distance = xValue - nextXValue;
+            if (distance > 0 &&
+                (typeof closestPointRange === 'undefined' || distance < closestPointRange)) {
+                closestPointRange = distance;
+            }
+        }
+    });
+    return closestPointRange;
+}

package/build/plugins/highcharts/renderer/helpers/highcharts/utils/calculateClosestPointManually.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/plugins/highcharts/renderer/helpers/highcharts/utils/calculateClosestPointManually.test.js

@@ -0,0 +1,42 @@
+import { calculateClosestPointManually } from './calcucalteClosestPointManually';
+describe('calculateClosestPointManually', () => {
+    it('Должна вернуть наименьшее расстояние между точками и если оно больше 0', () => {
+        const MOCKED_SERIES = [
+            {
+                processedXData: [1, 5, 12],
+            },
+            {
+                processedXData: [12, 65],
+            },
+            {
+                processedXData: [3, 140],
+            },
+        ];
+        const MOCKED_CONTEXT = {
+            series: MOCKED_SERIES,
+        };
+        const expectedResult = 2;
+        const result = calculateClosestPointManually.apply(MOCKED_CONTEXT);
+        expect(result).toEqual(expectedResult);
+    });
+    it('Должна вернуть undefined, если передан пустой массив', () => {
+        const MOCKED_CONTEXT = { series: [] };
+        const result = calculateClosestPointManually.apply(MOCKED_CONTEXT);
+        expect(result).toBeUndefined();
+    });
+    it('Должна вернуть undefined, если наименьшее расстояние это 0', () => {
+        const MOCKED_SERIES = [
+            {
+                processedXData: [12],
+            },
+            {
+                processedXData: [12],
+            },
+        ];
+        const MOCKED_CONTEXT = {
+            series: MOCKED_SERIES,
+        };
+        const result = calculateClosestPointManually.apply(MOCKED_CONTEXT);
+        expect(result).toBeUndefined();
+    });
+});

package/build/plugins/highcharts/renderer/helpers/highcharts/utils/index.d.ts

@@ -0,0 +1 @@
+export { calculateClosestPointManually } from './calcucalteClosestPointManually';

package/build/plugins/highcharts/renderer/helpers/highcharts/utils/index.js

@@ -0,0 +1 @@
+export { calculateClosestPointManually } from './calcucalteClosestPointManually';

package/build/plugins/highcharts/renderer/helpers/init-highcharts-modules.d.ts

@@ -0,0 +1 @@
+export function initHighchartsModules(): void;

package/build/plugins/highcharts/renderer/helpers/init-highcharts-modules.js

@@ -0,0 +1,49 @@
+import Highcharts from 'highcharts';
+import highchartsMore from 'highcharts/highcharts-more';
+import stock from 'highcharts/modules/stock';
+import solidGauge from 'highcharts/modules/solid-gauge';
+import funnel from 'highcharts/modules/funnel';
+import histogramBellcurve from 'highcharts/modules/histogram-bellcurve';
+import sankey from 'highcharts/modules/sankey';
+import heatmap from 'highcharts/modules/heatmap';
+import treemap from 'highcharts/modules/treemap';
+import variwide from 'highcharts/modules/variwide';
+import streamgraph from 'highcharts/modules/streamgraph';
+import drilldown from 'highcharts/modules/drilldown';
+import parallelCoordinates from 'highcharts/modules/parallel-coordinates';
+import patternFill from 'highcharts/modules/pattern-fill';
+import wordcloud from 'highcharts/modules/wordcloud';
+import xrange from 'highcharts/modules/xrange';
+import networkgraph from 'highcharts/modules/networkgraph';
+import timeline from 'highcharts/modules/timeline';
+import bullet from 'highcharts/modules/bullet';
+import annotations from 'highcharts/modules/annotations';
+import seriesLabel from 'highcharts/modules/series-label';
+import indicators from 'highcharts/indicators/indicators';
+import ema from 'highcharts/indicators/ema';
+import venn from 'highcharts/modules/venn';
+export function initHighchartsModules() {
+    highchartsMore(Highcharts);
+    stock(Highcharts);
+    solidGauge(Highcharts);
+    funnel(Highcharts);
+    histogramBellcurve(Highcharts);
+    sankey(Highcharts);
+    heatmap(Highcharts);
+    treemap(Highcharts);
+    variwide(Highcharts);
+    streamgraph(Highcharts);
+    drilldown(Highcharts);
+    annotations(Highcharts);
+    seriesLabel(Highcharts);
+    parallelCoordinates(Highcharts);
+    patternFill(Highcharts);
+    wordcloud(Highcharts);
+    xrange(Highcharts);
+    networkgraph(Highcharts);
+    timeline(Highcharts);
+    bullet(Highcharts);
+    venn(Highcharts);
+    indicators(Highcharts);
+    ema(Highcharts);
+}

package/build/plugins/highcharts/renderer/helpers/prepare-data.d.ts

@@ -0,0 +1 @@
+export function prepareData(data: any, options: any, holidays: any): void;

package/build/plugins/highcharts/renderer/helpers/prepare-data.js

@@ -0,0 +1,175 @@
+import moment from 'moment';
+import lodashMin from 'lodash/min';
+import { ChartKitError, CHARTKIT_ERROR_CODE } from '../../../../libs';
+function prepareValue(value, firstValue, options) {
+    if (value === null) {
+        return null;
+    }
+    if (options.normalizeDiv) {
+        return value / (firstValue || 1);
+    }
+    if (options.normalizeSub) {
+        return value - firstValue;
+    }
+    return value;
+}
+function sortByLastValue(a, b) {
+    if (a._lastValue < b._lastValue) {
+        return -1;
+    }
+    if (a._lastValue > b._lastValue) {
+        return 1;
+    }
+    return 0;
+}
+function sortByAlphabet(a, b) {
+    if (a.name < b.name) {
+        return -1;
+    }
+    if (a.name > b.name) {
+        return 1;
+    }
+    return 0;
+}
+const HIGHCHARTS_SCALE = {
+    s: 'second',
+    h: 'hour',
+    d: 'day',
+    w: 'week',
+    m: 'month',
+    q: 'quarter',
+    y: 'year',
+};
+function computeXTickScale(range) {
+    const timeUnits = {
+        s: 1000,
+        i: 60000,
+        h: 3600000,
+        d: 86400000,
+        w: 604800000,
+        m: 2419200000,
+        q: 7344000000,
+        y: 31449600000,
+    };
+    let previous = 's';
+    // eslint-disable-next-line guard-for-in
+    for (const current in timeUnits) {
+        if (timeUnits[current] > range) {
+            return previous;
+        }
+        previous = current;
+    }
+    return previous;
+}
+function removeHolidays(data, options, holidays) {
+    const timeline = [];
+    const graphsData = [];
+    data.graphs.forEach((graph, i) => {
+        graphsData[i] = [];
+    });
+    data.categories_ms.forEach((ts, i) => {
+        const datetime = moment(ts).format('YYYYMMDD');
+        const region = (options.region && options.region.toLowerCase()) || 'tot';
+        const holiday = holidays.holiday[region][datetime] || holidays.weekend[region][datetime];
+        if (!holiday) {
+            timeline.push(ts);
+            data.graphs.forEach((graph, j) => graphsData[j].push(graph.data[i]));
+        }
+    });
+    data.categories_ms = timeline;
+    data.graphs.forEach((graph, i) => {
+        graph.data = graphsData[i];
+    });
+}
+// eslint-disable-next-line complexity
+export function prepareData(data, options, holidays) {
+    if (!data ||
+        (typeof data === 'object' && !Object.keys(data).length) ||
+        (data.graphs &&
+            !(data.graphs.length && data.graphs.some((graph) => graph.data && graph.data.length))) ||
+        (Array.isArray(data) && !data.length)) {
+        throw new ChartKitError({ code: CHARTKIT_ERROR_CODE.NO_DATA });
+    }
+    if (data.graphs) {
+        if (data.graphs.length > 50 && !options.withoutLineLimit) {
+            throw new ChartKitError({ code: CHARTKIT_ERROR_CODE.TOO_MANY_LINES });
+        }
+        data.graphs.forEach((graph) => {
+            graph.name = graph.name || graph.title;
+        });
+        let min = false;
+        let max = false;
+        if (data.categories_ms) {
+            options.highchartsScale = HIGHCHARTS_SCALE[options.scale];
+            const closestPointRange = lodashMin(data.categories_ms.map((timestamp, index) => timestamp - data.categories_ms[index - 1]));
+            options.scale = options.scale || computeXTickScale(closestPointRange);
+            if (options.scale && options.scale.length > 1) {
+                const match = options.scale.match(/^[sihyqmwd]/g);
+                options.scale = match ? match[0] : null;
+            }
+            data.graphs
+                .filter(({ data }) => Boolean(data))
+                .forEach((graph, index) => {
+                let result = [];
+                const aloneOrHasNull = graph.data.length === 1 || graph.data.indexOf(null) !== -1;
+                const firstValue = graph.data[0];
+                if (aloneOrHasNull) {
+                    result = graph.data.map((val, pos) => {
+                        if (val !== null && typeof val === 'object') {
+                            return val;
+                        }
+                        const preparedVal = prepareValue(val, firstValue, options);
+                        const currentPoint = {
+                            x: data.categories_ms[pos],
+                            y: preparedVal,
+                        };
+                        if (preparedVal !== null) {
+                            min = Math.min(min, preparedVal);
+                            max = Math.max(max, preparedVal);
+                        }
+                        return currentPoint;
+                    });
+                }
+                else {
+                    result = graph.data.map((val, pos) => {
+                        if (val !== null && typeof val === 'object') {
+                            return val;
+                        }
+                        const preparedVal = prepareValue(val, firstValue, options);
+                        min = Math.min(min, preparedVal);
+                        max = Math.max(max, preparedVal);
+                        return [data.categories_ms[pos], preparedVal];
+                    });
+                }
+                data.graphs[index].data = result;
+            });
+            delete data.categories;
+        }
+        if (data.categories) {
+            delete data.categories_ms;
+        }
+        if (options.orderType === 'byLastValue') {
+            data.graphs.forEach((graphItem) => {
+                graphItem._lastValue =
+                    (graphItem.data &&
+                        graphItem.data[graphItem.data.length - 1] &&
+                        (graphItem.data[graphItem.data.length - 1][1] ||
+                            graphItem.data[graphItem.data.length - 1].y)) ||
+                        0;
+            });
+            data.graphs.sort(sortByLastValue);
+        }
+        if (options.orderType === 'alphabet') {
+            data.graphs.sort(sortByAlphabet);
+        }
+        if ((options.orderType === 'byLastValue' || options.orderType === 'alphabet') &&
+            options.orderSort === 'fromBottom') {
+            data.graphs.reverse();
+        }
+        if (holidays && options.hideHolidays) {
+            removeHolidays(data, options, holidays);
+        }
+        options.max = max;
+        options.min = min;
+    }
+}

package/build/plugins/highcharts/renderer/helpers/tooltip/constants.d.ts

@@ -0,0 +1,13 @@
+export declare enum LineShapeType {
+    Solid = "Solid",
+    ShortDash = "ShortDash",
+    ShortDot = "ShortDot",
+    ShortDashDot = "ShortDashDot",
+    ShortDashDotDot = "ShortDashDotDot",
+    Dot = "Dot",
+    Dash = "Dash",
+    LongDash = "LongDash",
+    DashDot = "DashDot",
+    LongDashDot = "LongDashDot",
+    LongDashDotDot = "LongDashDotDot"
+}

package/build/plugins/highcharts/renderer/helpers/tooltip/constants.js

@@ -0,0 +1,14 @@
+export var LineShapeType;
+(function (LineShapeType) {
+    LineShapeType["Solid"] = "Solid";
+    LineShapeType["ShortDash"] = "ShortDash";
+    LineShapeType["ShortDot"] = "ShortDot";
+    LineShapeType["ShortDashDot"] = "ShortDashDot";
+    LineShapeType["ShortDashDotDot"] = "ShortDashDotDot";
+    LineShapeType["Dot"] = "Dot";
+    LineShapeType["Dash"] = "Dash";
+    LineShapeType["LongDash"] = "LongDash";
+    LineShapeType["DashDot"] = "DashDot";
+    LineShapeType["LongDashDot"] = "LongDashDot";
+    LineShapeType["LongDashDotDot"] = "LongDashDotDot";
+})(LineShapeType || (LineShapeType = {}));

package/build/plugins/highcharts/renderer/helpers/tooltip/helpers.d.ts

@@ -0,0 +1 @@
+export declare const escapeHTML: (html?: string) => string;