mdt-charts 1.9.7 → 1.9.11

package/lib/engine/features/recordOverflowAlert/recordOverflowAlert.js

@@ -1,97 +0,0 @@
-import { DomHelper } from '../../helpers/domHelper';
-import { Legend } from '../legend/legend';
-export class RecordOverflowAlert {
-    static render(block, hidedRecordsAmount, position, chartOrientation = null) {
-        const alertBlock = block.getWrapper()
-            .append('div')
-            .attr('class', this.blockClass)
-            .text(this.getAlertText(hidedRecordsAmount, chartOrientation));
-        const attrs = this.getBlockPositionAttrs(position, block);
-        this.setAlertPosition(alertBlock, attrs);
-    }
-    static update(block, hidedRecordsAmount, position, chartOrientation = null) {
-        let alertBlock = block.getWrapper()
-            .select(`div.${this.blockClass}`);
-        if (alertBlock.empty()) {
-            if (hidedRecordsAmount === 0)
-                return;
-            else
-                this.render(block, hidedRecordsAmount, position, chartOrientation);
-        }
-        else {
-            if (hidedRecordsAmount === 0)
-                alertBlock.remove();
-            else
-                alertBlock.text(this.getAlertText(hidedRecordsAmount, chartOrientation));
-        }
-    }
-    static setAlertPosition(alertBlock, attrs) {
-        alertBlock
-            .style('position', 'absolute')
-            .style('left', attrs.left)
-            .style('right', attrs.right)
-            .style('top', attrs.top)
-            .style('bottom', attrs.bottom);
-    }
-    static getAlertText(hidedRecordsAmount, chartOrientation) {
-        return `+ ${hidedRecordsAmount} ${this.getWordTextEndingByAmount(hidedRecordsAmount, chartOrientation)}`;
-    }
-    static getWordTextEndingByAmount(hidedRecordsAmount, chartOrientation) {
-        const lastDigit = hidedRecordsAmount % 10;
-        if (chartOrientation === 'vertical') {
-            if (hidedRecordsAmount >= 10 && hidedRecordsAmount <= 20)
-                return 'столбцов';
-            if (lastDigit === 1)
-                return 'столбец';
-            if (lastDigit >= 2 && lastDigit <= 4)
-                return 'столбца';
-            return 'столбцов';
-        }
-        else if (chartOrientation === 'horizontal') {
-            if (hidedRecordsAmount >= 10 && hidedRecordsAmount <= 20)
-                return 'строк';
-            if (lastDigit === 1)
-                return 'строка';
-            if (lastDigit >= 2 && lastDigit <= 4)
-                return 'строки';
-            return 'строк';
-        }
-        else {
-            if (hidedRecordsAmount >= 10 && hidedRecordsAmount <= 20)
-                return 'категорий';
-            if (lastDigit === 1)
-                return 'категория';
-            if (lastDigit >= 2 && lastDigit <= 4)
-                return 'категории';
-            return 'категорий';
-        }
-    }
-    static getBlockPositionAttrs(position, block) {
-        const attrs = {
-            bottom: null,
-            top: null,
-            right: null,
-            left: null
-        };
-        if (position === 'top') {
-            attrs.right = '17px';
-            attrs.top = '1rem';
-        }
-        if (position === 'right') {
-            attrs.bottom = '20px';
-            attrs.left = this.getLeftAttrForRightBlock(block) + 'px';
-        }
-        if (position === 'bottom') {
-            attrs.left = '20px';
-            attrs.bottom = '20px';
-        }
-        return attrs;
-    }
-    static getLeftAttrForRightBlock(block) {
-        const legendBlock = block.getSvg().select(`.${Legend.objectClass}`);
-        if (legendBlock.empty())
-            return null;
-        return DomHelper.getSelectionNumericAttr(legendBlock, 'x');
-    }
-}
-RecordOverflowAlert.blockClass = 'record-overflow-alert';

package/lib/engine/features/scale/scale.d.ts

@@ -1,16 +0,0 @@
-import { AxisScale } from 'd3-axis';
-import { BarChartSettings, ScaleKeyModel, ScaleValueModel } from '../../../model/model';
-export interface Scales {
-    key: AxisScale<any>;
-    value: AxisScale<any>;
-}
-export declare class Scale {
-    static getScales(scaleKey: ScaleKeyModel, scaleValue: ScaleValueModel, bandSettings: BarChartSettings): Scales;
-    static getScaleBandWidth(scale: AxisScale<any>): number;
-    static getScaleStep(scale: AxisScale<any>): number;
-    static getScaledValue(scale: AxisScale<any>, value: any): number;
-    private static getScaleBand;
-    private static getScaleLinear;
-    private static getScalePoint;
-    private static getScaleTime;
-}

package/lib/engine/features/scale/scale.js

@@ -1,74 +0,0 @@
-import { scaleBand, scaleLinear, scalePoint, scaleTime } from 'd3-scale';
-export class Scale {
-    static getScales(scaleKey, scaleValue, bandSettings) {
-        const scales = {
-            key: null,
-            value: null
-        };
-        if (scaleKey.type === 'band')
-            scales.key = this.getScaleBand(scaleKey.domain, scaleKey.range, bandSettings, scaleKey.elementsAmount);
-        else if (scaleKey.type === 'point')
-            scales.key = this.getScalePoint(scaleKey.domain, scaleKey.range);
-        if (scaleValue.type === 'linear')
-            scales.value = this.getScaleLinear(scaleValue.domain, scaleValue.range);
-        else if (scaleValue.type === 'datetime')
-            scales.value = this.getScaleTime(scaleValue.domain, scaleValue.range);
-        return scales;
-    }
-    static getScaleBandWidth(scale) {
-        if (scale.bandwidth && scale.bandwidth() !== 0) {
-            return scale.bandwidth();
-        }
-        else if (scale.step) {
-            return scale.step();
-        }
-    }
-    static getScaleStep(scale) {
-        if (scale.step) {
-            return scale.step();
-        }
-    }
-    static getScaledValue(scale, value) {
-        if (scale.bandwidth && scale.bandwidth() !== 0) {
-            return scale(value) + this.getScaleBandWidth(scale) / 2;
-        }
-        return scale(value);
-    }
-    static getScaleBand(domain, range, bandSettings, elementsInGroupAmount) {
-        const scale = scaleBand()
-            .domain(domain)
-            .range([range.start, range.end]);
-        const bandSize = scale.bandwidth();
-        if (bandSettings.groupMinDistance < bandSize) {
-            scale.paddingInner(bandSettings.groupMinDistance / bandSize);
-            scale.paddingOuter(bandSettings.groupMinDistance / bandSize / 2);
-        }
-        // Padding inner = 10. If bandwidth more than needed, paddingInner is increased to number less than 35 
-        let paddingInner = bandSettings.groupMinDistance;
-        while (scale.bandwidth() > bandSettings.maxBarWidth * elementsInGroupAmount + bandSettings.barDistance * (elementsInGroupAmount - 1) && paddingInner < bandSettings.groupMaxDistance) {
-            scale.paddingInner(++paddingInner / bandSize);
-        }
-        // if bandwidth more than all bars widths in group + distance between it + distance between groups
-        let paddingOuter = 1;
-        while (scale.step() > bandSettings.maxBarWidth * elementsInGroupAmount + bandSettings.groupMaxDistance + bandSettings.barDistance * (elementsInGroupAmount - 1)) {
-            scale.paddingOuter(++paddingOuter / bandSize);
-        }
-        return scale;
-    }
-    static getScaleLinear(domain, range) {
-        return scaleLinear()
-            .domain(domain)
-            .range([range.start, range.end]);
-    }
-    static getScalePoint(domain, range) {
-        return scalePoint()
-            .domain(domain)
-            .range([range.start, range.end]);
-    }
-    static getScaleTime(domain, range) {
-        return scaleTime()
-            .domain(domain)
-            .range([range.start, range.end])
-            .nice();
-    }
-}

package/lib/engine/features/tipBox/tipBox.d.ts

@@ -1,11 +0,0 @@
-import { Selection } from 'd3-selection';
-import { Block } from "../../block/block";
-import { BlockMargin } from '../../../model/model';
-import { Size } from "../../../config/config";
-export declare class TipBox {
-    static readonly tipBoxClass = "tipbox";
-    static renderOrGet(block: Block, margin: BlockMargin, blockSize: Size): Selection<SVGRectElement, unknown, HTMLElement, any>;
-    static get(block: Block): Selection<SVGRectElement, unknown, HTMLElement, any>;
-    static clearEvents(block: Block): void;
-    private static renderBlock;
-}

package/lib/engine/features/tipBox/tipBox.js

@@ -1,32 +0,0 @@
-import { TipBoxHelper } from './tipBoxHelper';
-export class TipBox {
-    static renderOrGet(block, margin, blockSize) {
-        const attributes = TipBoxHelper.getAttributes(margin, blockSize);
-        return this.renderBlock(block, attributes);
-    }
-    static get(block) {
-        return block.getSvg().select(`.${this.tipBoxClass}`);
-    }
-    static clearEvents(block) {
-        block.getSvg()
-            .select(`.${this.tipBoxClass}`)
-            .on('mousemove', null)
-            .on('mouseleave', null)
-            .on('click', null);
-    }
-    static renderBlock(block, attributes) {
-        let tipBox = block.getSvg()
-            .select(`rect.${this.tipBoxClass}`);
-        if (tipBox.empty())
-            tipBox = block.getSvg()
-                .append('rect')
-                .attr('class', this.tipBoxClass)
-                .attr('x', attributes.x)
-                .attr('y', attributes.y)
-                .attr('width', attributes.width)
-                .attr('height', attributes.height)
-                .style('opacity', 0);
-        return tipBox;
-    }
-}
-TipBox.tipBoxClass = 'tipbox';

package/lib/engine/features/tipBox/tipBoxHelper.d.ts

@@ -1,16 +0,0 @@
-import { AxisScale } from "d3-axis";
-import { ChartOrientation, Size } from "../../../config/config";
-import { BlockMargin, ScaleKeyType } from "../../../model/model";
-export interface TipBoxAttributes {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-export declare class TipBoxHelper {
-    static getKeyValueByPointer(pointer: [number, number], chartOrient: ChartOrientation, margin: BlockMargin, blockSize: Size, scaleKey: AxisScale<any>, scaleKeyType: ScaleKeyType): string;
-    static getAttributes(margin: BlockMargin, blockSize: Size): TipBoxAttributes;
-    private static getKeyIndex;
-    private static getKeyIndexOfPoint;
-    private static getKeyIndexOfBand;
-}

package/lib/engine/features/tipBox/tipBoxHelper.js

@@ -1,48 +0,0 @@
-import { Scale } from "../scale/scale";
-export class TipBoxHelper {
-    static getKeyValueByPointer(pointer, chartOrient, margin, blockSize, scaleKey, scaleKeyType) {
-        const index = TipBoxHelper.getKeyIndex(pointer, chartOrient, margin, blockSize, scaleKey, scaleKeyType);
-        let keyValue = scaleKey.domain()[index];
-        if (index >= scaleKey.domain().length)
-            keyValue = scaleKey.domain()[scaleKey.domain().length - 1];
-        return keyValue;
-    }
-    static getAttributes(margin, blockSize) {
-        const pad = 5;
-        return {
-            x: margin.left - pad,
-            y: margin.top - pad,
-            width: blockSize.width - margin.left - margin.right + pad * 2,
-            height: blockSize.height - margin.top - margin.bottom + pad * 2,
-        };
-    }
-    static getKeyIndex(pointer, chartOrient, margin, blockSize, scaleKey, scaleKeyType) {
-        const pointerAxisType = chartOrient === 'vertical' ? 0 : 1; // 0 - координата поинтера по оси x, 1 - по оси y
-        const marginByOrient = chartOrient === 'vertical' ? margin.left : margin.top;
-        const scaleStep = Scale.getScaleStep(scaleKey);
-        if (scaleKeyType === 'point') {
-            return this.getKeyIndexOfPoint(pointer, scaleStep, marginByOrient, pointerAxisType);
-        }
-        else {
-            return this.getKeyIndexOfBand(pointer, scaleStep, marginByOrient, pointerAxisType, blockSize, margin, chartOrient, scaleKey);
-        }
-    }
-    static getKeyIndexOfPoint(pointer, scaleStep, marginByOrient, pointerAxisType) {
-        const point = pointer[pointerAxisType] - marginByOrient + scaleStep / 2;
-        if (point < 0)
-            return 0;
-        return Math.floor(point / scaleStep);
-    }
-    static getKeyIndexOfBand(pointer, scaleStep, marginByOrient, pointerAxisType, blockSize, margin, chartOrient, scaleKey) {
-        const chartBlockSizeByDir = chartOrient === 'vertical'
-            ? blockSize.width - margin.left - margin.right
-            : blockSize.height - margin.top - margin.bottom;
-        const outerPadding = chartBlockSizeByDir - scaleStep * scaleKey.domain().length;
-        if (pointer[pointerAxisType] - marginByOrient - 1 < outerPadding / 2)
-            return 0; // Самый первый элемент
-        if (pointer[pointerAxisType] - marginByOrient - 1 + outerPadding / 2 > chartBlockSizeByDir)
-            return scaleKey.domain().length - 1; // последний индекс
-        const point = pointer[pointerAxisType] - outerPadding / 2 - marginByOrient - 1;
-        return Math.floor(point / scaleStep);
-    }
-}

package/lib/engine/features/title/title.d.ts

@@ -1,9 +0,0 @@
-import { Size } from '../../../config/config';
-import { TitleBlockModel } from "../../../model/model";
-import { Block } from "../../block/block";
-export declare class Title {
-    static render(block: Block, text: string, titleBlockModel: TitleBlockModel, blockSize: Size): void;
-    private static fillTitleBlockAttributes;
-    private static getTitleAttributes;
-    private static setTitleTooltip;
-}

package/lib/engine/features/title/title.js

@@ -1,35 +0,0 @@
-import { DomHelper } from '../../helpers/domHelper';
-export class Title {
-    static render(block, text, titleBlockModel, blockSize) {
-        const titleBlock = block.getSvg()
-            .append('text')
-            .attr('class', 'chart-title');
-        const titleCoordinate = this.getTitleAttributes(blockSize, titleBlockModel);
-        this.fillTitleBlockAttributes(titleBlock, titleCoordinate, text);
-        this.setTitleTooltip(titleBlock, text);
-    }
-    static fillTitleBlockAttributes(titleBlock, attributes, text) {
-        titleBlock
-            .attr('x', attributes.x)
-            .attr('y', attributes.y)
-            .attr('dominant-baseline', attributes.dominantBaseline)
-            .text(text);
-        DomHelper.cropSvgLabels(titleBlock, attributes.maxWidth);
-    }
-    static getTitleAttributes(blockSize, titleBlockModel) {
-        const coordinate = {
-            x: 0,
-            y: 0,
-            maxWidth: 0,
-            dominantBaseline: "hanging"
-        };
-        coordinate.x = titleBlockModel.margin.left;
-        coordinate.y = titleBlockModel.margin.top;
-        coordinate.maxWidth = blockSize.width - titleBlockModel.margin.left - titleBlockModel.margin.right;
-        return coordinate;
-    }
-    static setTitleTooltip(titleBlock, text) {
-        titleBlock.append('title')
-            .text(text);
-    }
-}

package/lib/engine/features/tolltip/tooltip.d.ts

@@ -1,19 +0,0 @@
-import { Model } from "../../../model/model";
-import { Block } from "../../block/block";
-import { MdtChartsDataSource } from "../../../config/config";
-import { Scales } from '../scale/scale';
-import { TooltipSettings } from '../../../designer/designerConfig';
-export declare class Tooltip {
-    static readonly tooltipBlockClass = "tooltip-block";
-    static readonly tooltipLineClass = "tooltip-line";
-    static readonly tooltipWrapperClass = "tooltip-wrapper";
-    static readonly tooltipContentClass = "tooltip-content";
-    static readonly tooltipArrowClass = "tooltip-arrow";
-    static render(block: Block, model: Model, data: MdtChartsDataSource, tooltipOptions: TooltipSettings, scales?: Scales): void;
-    static hide(block: Block): void;
-    private static renderTooltipFor2DCharts;
-    private static renderTooltipForIntervalCharts;
-    private static renderTooltipForPolar;
-    private static renderLineTooltip;
-    private static renderTooltipForDonut;
-}

package/lib/engine/features/tolltip/tooltip.js

@@ -1,180 +0,0 @@
-import { select, pointer, } from 'd3-selection';
-import { TooltipDomHelper } from "./tooltipDomHelper";
-import { Donut } from "../../polarNotation/donut/donut";
-import { TooltipComponentsManager } from './tooltipComponentsManager';
-import { ElementHighlighter } from '../../elementHighlighter/elementHighlighter';
-import { DonutHelper } from '../../polarNotation/donut/DonutHelper';
-import { TipBox } from '../tipBox/tipBox';
-import { TipBoxHelper } from '../tipBox/tipBoxHelper';
-import { Helper } from '../../helpers/helper';
-import { TooltipHelper } from './tooltipHelper';
-import { DomHelper } from '../../helpers/domHelper';
-export class Tooltip {
-    static render(block, model, data, tooltipOptions, scales) {
-        TooltipComponentsManager.renderTooltipWrapper(block);
-        const withTooltipIndex = model.options.charts.findIndex((chart) => chart.tooltip.show);
-        if (withTooltipIndex !== -1) {
-            if (model.options.type === '2d') {
-                this.renderTooltipFor2DCharts(block, data, model.blockCanvas.size, model.chartBlock.margin, scales, model.options, tooltipOptions);
-            }
-            else if (model.options.type === 'polar') {
-                this.renderTooltipForPolar(block, model.options, data, model.blockCanvas.size, model.chartBlock.margin, DonutHelper.getThickness(model.chartSettings.donut, model.blockCanvas.size, model.chartBlock.margin), model.otherComponents.tooltipBlock);
-            }
-            else if (model.options.type === 'interval') {
-                this.renderTooltipForIntervalCharts(block, data, model.blockCanvas.size, model.chartBlock.margin, scales, model.options, tooltipOptions);
-            }
-        }
-    }
-    static hide(block) {
-        TooltipComponentsManager.hideComponent(block.getWrapper().select(`.${this.tooltipBlockClass}`));
-        TooltipComponentsManager.hideComponent(block.getSvg().select(`.${this.tooltipLineClass}`));
-    }
-    static renderTooltipFor2DCharts(block, data, blockSize, margin, scales, options, tooltipOptions) {
-        if (scales.key.domain().length === 0)
-            return;
-        const tooltipParams = {
-            type: '2d',
-            scales,
-            margin,
-            blockSize,
-            charts: options.charts,
-            chartOrientation: options.orient,
-            keyAxisOrient: options.axis.key.orient,
-            dataOptions: options.data,
-            scaleKeyModel: options.scale.key,
-            tooltipSettings: tooltipOptions,
-            tooltipOptions: options.tooltip
-        };
-        this.renderLineTooltip(block, data, tooltipParams);
-    }
-    static renderTooltipForIntervalCharts(block, data, blockSize, margin, scales, options, tooltipOptions) {
-        if (scales.key.domain().length === 0)
-            return;
-        const tooltipParams = {
-            type: 'interval',
-            scales,
-            margin,
-            blockSize,
-            charts: options.charts,
-            chartOrientation: options.orient,
-            keyAxisOrient: options.axis.key.orient,
-            dataOptions: options.data,
-            scaleKeyModel: options.scale.key,
-            tooltipSettings: tooltipOptions,
-            tooltipOptions: options.tooltip
-        };
-        this.renderLineTooltip(block, data, tooltipParams);
-    }
-    static renderTooltipForPolar(block, options, data, blockSize, margin, chartThickness, tooltipOptions) {
-        const attrTransform = block.getSvg().select(`.${Donut.donutBlockClass}`).attr('transform');
-        const translateNums = Helper.getTranslateNumbers(attrTransform);
-        const arcItems = Donut.getAllArcGroups(block);
-        this.renderTooltipForDonut(block, arcItems, data, options.data, options.charts[0], blockSize, margin, chartThickness, tooltipOptions, options.tooltip, { x: translateNums[0], y: translateNums[1] });
-    }
-    static renderLineTooltip(block, data, args) {
-        const tooltipBlock = TooltipComponentsManager.renderTooltipBlock(block);
-        const tooltipContent = TooltipComponentsManager.renderTooltipContentBlock(tooltipBlock);
-        const tooltipLine = TooltipComponentsManager.renderTooltipLine(block);
-        const tipBox = TipBox.renderOrGet(block, args.margin, args.blockSize);
-        let currentKey = null;
-        tipBox.on('mousemove', function (e) {
-            var _a, _b;
-            const keyValue = e.detail.keyValue || TipBoxHelper.getKeyValueByPointer(pointer(e, this), args.chartOrientation, args.margin, args.blockSize, args.scales.key, args.scaleKeyModel.type);
-            if (args.tooltipSettings.position === 'followCursor') {
-                const tooltipCoordinate = TooltipHelper.getTooltipCursorCoordinate(e.detail.pointer || pointer(e, this), block.getSvg().node().getBoundingClientRect(), tooltipContent.node().getBoundingClientRect(), window.innerWidth, window.innerHeight);
-                TooltipComponentsManager.setLineTooltipCoordinate(tooltipBlock, tooltipCoordinate, args.chartOrientation, 0);
-            }
-            if (!currentKey || currentKey !== keyValue) {
-                TooltipComponentsManager.showComponent(tooltipBlock);
-                if (args.type === '2d')
-                    TooltipDomHelper.fillForMulty2DCharts(tooltipContent, args.charts.filter(ch => ch.tooltip.show), data, args.dataOptions, keyValue, (_a = args.tooltipOptions) === null || _a === void 0 ? void 0 : _a.html);
-                else
-                    TooltipDomHelper.fillForIntervalChart(tooltipContent, args.charts.filter(ch => ch.tooltip.show), data, args.dataOptions, keyValue, (_b = args.tooltipOptions) === null || _b === void 0 ? void 0 : _b.html);
-                if (args.tooltipSettings.position === 'fixed') {
-                    const tooltipCoordinate = TooltipHelper.getTooltipFixedCoordinate(args.scales.key, args.margin, keyValue, block.getSvg().node().getBoundingClientRect(), tooltipContent.node().getBoundingClientRect(), args.keyAxisOrient, window.innerWidth, window.innerHeight);
-                    TooltipComponentsManager.setLineTooltipCoordinate(tooltipBlock, tooltipCoordinate, args.chartOrientation, block.transitionManager.durations.tooltipSlide);
-                }
-                const tooltipLineAttributes = TooltipHelper.getTooltipLineAttributes(args.scales.key, args.margin, keyValue, args.chartOrientation, args.blockSize);
-                TooltipComponentsManager.setTooltipLineAttributes(tooltipLine, tooltipLineAttributes, block.transitionManager.durations.tooltipSlide);
-                TooltipComponentsManager.showComponent(tooltipLine);
-                //TODO: append highlight for interval / Extract this highlighting in method 
-                if (args.type === '2d') {
-                    args.charts.forEach(chart => {
-                        const elements = DomHelper.get2DChartElements(block, chart);
-                        if (!block.filterEventManager.isSelected(currentKey)) {
-                            const oldElements = DomHelper.getChartElementsByKeys(elements, chart.isSegmented, args.dataOptions.keyField.name, [currentKey]);
-                            if (chart.type !== 'bar' && !chart.markersOptions.show)
-                                ElementHighlighter.toggleMarkDotVisible(oldElements, false);
-                            ElementHighlighter.toggle2DElements(oldElements, false, chart.type, block.transitionManager.durations.markerHover);
-                            if (block.filterEventManager.getSelectedKeys().length > 0) {
-                                ElementHighlighter.toggleActivityStyle(oldElements, false);
-                            }
-                        }
-                        const selectedElements = DomHelper.getChartElementsByKeys(elements, chart.isSegmented, args.dataOptions.keyField.name, [keyValue]);
-                        if (chart.type !== 'bar' && !chart.markersOptions.show)
-                            ElementHighlighter.toggleMarkDotVisible(selectedElements, true);
-                        ElementHighlighter.toggleActivityStyle(selectedElements, true);
-                        if (block.filterEventManager.getSelectedKeys().length === 0 || block.filterEventManager.isSelected(keyValue)) {
-                            ElementHighlighter.toggle2DElements(selectedElements, true, chart.type, block.transitionManager.durations.markerHover);
-                        }
-                    });
-                }
-                currentKey = keyValue;
-            }
-        });
-        tipBox.on('mouseleave', function () {
-            TooltipComponentsManager.hideComponent(tooltipBlock);
-            TooltipComponentsManager.hideComponent(tooltipLine);
-            if (args.type === '2d')
-                ElementHighlighter.removeUnselected2DHighlight(block, args.dataOptions.keyField.name, args.charts, block.transitionManager.durations.markerHover);
-            currentKey = null;
-        });
-    }
-    static renderTooltipForDonut(block, elements, data, dataOptions, chart, blockSize, margin, donutThickness, tooltipSettings, tooltipOptions, translate) {
-        const tooltipBlock = TooltipComponentsManager.renderTooltipBlock(block);
-        const tooltipContent = TooltipComponentsManager.renderTooltipContentBlock(tooltipBlock);
-        let tooltipArrow;
-        if (tooltipSettings.position === 'fixed')
-            tooltipArrow = TooltipComponentsManager.renderTooltipArrow(tooltipBlock);
-        if (tooltipSettings.position === 'followCursor') {
-            elements.on('mousemove', function (e) {
-                const pointerCoordinate = !pointer(e, block.getSvg().node())[0] ? e.detail.pointer : pointer(e, block.getSvg().node());
-                const tooltipCoordinate = TooltipHelper.getTooltipCursorCoordinate(pointerCoordinate, block.getSvg().node().getBoundingClientRect(), tooltipContent.node().getBoundingClientRect(), window.innerWidth, window.innerHeight);
-                TooltipComponentsManager.setBlockCoordinate(tooltipBlock, tooltipCoordinate);
-            });
-        }
-        elements.on('mouseover', function (e, dataRow) {
-            TooltipComponentsManager.showComponent(tooltipBlock);
-            TooltipDomHelper.fillForPolarChart(tooltipContent, chart, data, dataOptions, dataRow.data[dataOptions.keyField.name], select(this).select('path').style('fill'), tooltipOptions === null || tooltipOptions === void 0 ? void 0 : tooltipOptions.html);
-            if (tooltipSettings.position === 'fixed') {
-                const coordinatePointer = TooltipDomHelper.getRecalcedCoordinateByArrow(DonutHelper.getArcCentroid(blockSize, margin, dataRow, donutThickness), tooltipBlock, blockSize, tooltipArrow, translate.x, translate.y);
-                coordinatePointer[0] = coordinatePointer[0] + translate.x;
-                coordinatePointer[1] = coordinatePointer[1] + translate.y;
-                const tooltipCoordinate = TooltipHelper.getCoordinateByPointer(coordinatePointer);
-                TooltipComponentsManager.setBlockCoordinate(tooltipBlock, tooltipCoordinate);
-            }
-            ElementHighlighter.toggleActivityStyle(select(this), true);
-            const clones = Donut.getAllArcClones(block)
-                .filter((d) => d.data[dataOptions.keyField.name] === dataRow.data[dataOptions.keyField.name]);
-            if (clones.nodes().length === 0 && (block.filterEventManager.getSelectedKeys().length === 0 || block.filterEventManager.isSelected(dataRow.data[dataOptions.keyField.name]))) {
-                ElementHighlighter.renderArcCloneAndHighlight(block, margin, select(this), blockSize, donutThickness);
-            }
-        });
-        elements.on('mouseleave', function (e, dataRow) {
-            TooltipComponentsManager.hideComponent(tooltipBlock);
-            if (!block.filterEventManager.isSelected(dataRow.data[dataOptions.keyField.name])) {
-                ElementHighlighter.removeCloneForElem(block, dataOptions.keyField.name, select(this));
-                ElementHighlighter.removeShadowClone(block, dataOptions.keyField.name, select(this), margin, blockSize, donutThickness);
-                ElementHighlighter.toggleDonutHighlightState(select(this), margin, blockSize, donutThickness, block.transitionManager.durations.higlightedScale, false);
-                if (block.filterEventManager.getSelectedKeys().length > 0) {
-                    ElementHighlighter.toggleActivityStyle(select(this), false);
-                }
-            }
-        });
-    }
-}
-Tooltip.tooltipBlockClass = 'tooltip-block';
-Tooltip.tooltipLineClass = 'tooltip-line';
-Tooltip.tooltipWrapperClass = 'tooltip-wrapper';
-Tooltip.tooltipContentClass = 'tooltip-content';
-Tooltip.tooltipArrowClass = 'tooltip-arrow';

package/lib/engine/features/tolltip/tooltipComponentsManager.d.ts

@@ -1,17 +0,0 @@
-import { Selection, BaseType } from 'd3-selection';
-import { Block } from "../../block/block";
-import { TooltipCoordinate, TooltipLineAttributes } from "./tooltipDomHelper";
-import { ChartOrientation } from "../../../config/config";
-export declare class TooltipComponentsManager {
-    static showComponent(tooltipBlock: Selection<BaseType, unknown, HTMLElement, any>): void;
-    static hideComponent(tooltipBlock: Selection<BaseType, unknown, HTMLElement, any>): void;
-    static renderTooltipWrapper(block: Block): void;
-    static renderTooltipBlock(block: Block, translateX?: number, translateY?: number): Selection<HTMLElement, unknown, HTMLElement, any>;
-    static renderTooltipContentBlock(tooltipBlock: Selection<BaseType, unknown, HTMLElement, any>): Selection<HTMLDivElement, unknown, HTMLElement, any>;
-    static renderTooltipLine(block: Block): Selection<SVGLineElement, unknown, HTMLElement, any>;
-    static setTooltipLineAttributes(tooltipLine: Selection<SVGLineElement, unknown, HTMLElement, any>, attributes: TooltipLineAttributes, transition: number): void;
-    static getLineWidth(tooltipLine: Selection<BaseType, any, BaseType, any>): number;
-    static renderTooltipArrow(tooltipBlock: Selection<BaseType, unknown, HTMLElement, any>): Selection<BaseType, unknown, HTMLElement, any>;
-    static setBlockCoordinate(tooltipBlock: Selection<BaseType, unknown, HTMLElement, any>, tooltipCoordinate: TooltipCoordinate): void;
-    static setLineTooltipCoordinate(tooltipBlock: Selection<BaseType, unknown, HTMLElement, any>, tooltipCoordinate: TooltipCoordinate, chartOrientation: ChartOrientation, transition?: number): void;
-}