mdt-charts 1.9.7 → 1.9.11

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

@@ -1,127 +0,0 @@
-import { ARROW_DEFAULT_POSITION, ARROW_SIZE } from "./tooltipDomHelper";
-import { easeLinear } from 'd3-ease';
-import { interrupt } from 'd3-transition';
-import { Tooltip } from './tooltip';
-export class TooltipComponentsManager {
-    static showComponent(tooltipBlock) {
-        tooltipBlock.style('display', 'block');
-    }
-    static hideComponent(tooltipBlock) {
-        tooltipBlock.style('display', 'none');
-    }
-    static renderTooltipWrapper(block) {
-        let tooltipWrapper = block.getWrapper()
-            .select(`.${Tooltip.tooltipWrapperClass}`);
-        if (tooltipWrapper.empty())
-            block.getWrapper()
-                .append('div')
-                .attr('class', Tooltip.tooltipWrapperClass);
-    }
-    static renderTooltipBlock(block, translateX = 0, translateY = 0) {
-        const wrapper = block.getWrapper().select(`.${Tooltip.tooltipWrapperClass}`);
-        let tooltipBlock = wrapper.select(`.${Tooltip.tooltipBlockClass}`);
-        if (tooltipBlock.empty()) {
-            tooltipBlock = wrapper
-                .append('div')
-                .attr('class', Tooltip.tooltipBlockClass)
-                .style('position', 'absolute')
-                .style('display', 'none');
-        }
-        if (translateX !== 0 || translateY !== 0)
-            tooltipBlock.style('transform', `translate(${translateX}px, ${translateY}px)`);
-        return tooltipBlock;
-    }
-    static renderTooltipContentBlock(tooltipBlock) {
-        let tooltipContentBlock = tooltipBlock.select(`.${Tooltip.tooltipContentClass}`);
-        if (tooltipContentBlock.empty())
-            tooltipContentBlock = tooltipBlock.append('div')
-                .attr('class', Tooltip.tooltipContentClass);
-        return tooltipContentBlock;
-    }
-    static renderTooltipLine(block) {
-        let tooltipLine = block.getChartBlock()
-            .select(`.${Tooltip.tooltipLineClass}`);
-        if (tooltipLine.empty())
-            tooltipLine = block.getChartBlock()
-                .append('line')
-                .attr('class', Tooltip.tooltipLineClass)
-                .lower();
-        return tooltipLine;
-    }
-    static setTooltipLineAttributes(tooltipLine, attributes, transition) {
-        interrupt(tooltipLine.node());
-        if (transition > 0 && tooltipLine.style('display') === 'block') {
-            tooltipLine
-                .interrupt()
-                .transition()
-                .duration(transition)
-                .ease(easeLinear)
-                .attr('x1', attributes.x1)
-                .attr('x2', attributes.x2)
-                .attr('y1', attributes.y1)
-                .attr('y2', attributes.y2);
-        }
-        else {
-            tooltipLine
-                .attr('x1', attributes.x1)
-                .attr('x2', attributes.x2)
-                .attr('y1', attributes.y1)
-                .attr('y2', attributes.y2);
-        }
-    }
-    static getLineWidth(tooltipLine) {
-        return parseFloat(tooltipLine.style('stroke-width'));
-    }
-    static renderTooltipArrow(tooltipBlock) {
-        let arrowSize = ARROW_SIZE / 2;
-        let tooltipArrow = tooltipBlock.select(`.${Tooltip.tooltipArrowClass}`);
-        if (tooltipArrow.empty())
-            tooltipArrow = tooltipBlock
-                .append('div')
-                .attr('class', Tooltip.tooltipArrowClass)
-                .style('position', 'absolute')
-                .style('left', `${ARROW_DEFAULT_POSITION}px`)
-                .style('border-top-width', `${arrowSize}px`)
-                .style('border-right-width', `${arrowSize}px`)
-                .style('border-bottom-width', `0px`)
-                .style('border-left-width', `${arrowSize}px`);
-        return tooltipArrow;
-    }
-    static setBlockCoordinate(tooltipBlock, tooltipCoordinate) {
-        tooltipBlock
-            .style('right', tooltipCoordinate.right)
-            .style('bottom', tooltipCoordinate.bottom)
-            .style('left', tooltipCoordinate.left)
-            .style('top', tooltipCoordinate.top);
-    }
-    static setLineTooltipCoordinate(tooltipBlock, tooltipCoordinate, chartOrientation, transition = null) {
-        interrupt(tooltipBlock.node());
-        if (!transition || transition <= 0)
-            this.setBlockCoordinate(tooltipBlock, tooltipCoordinate);
-        if (chartOrientation === 'vertical' && tooltipBlock.style('left') !== '0px' && tooltipBlock.style('right') !== '0px' && tooltipCoordinate.right !== '0px' && tooltipCoordinate.left !== null) {
-            tooltipBlock
-                .style('right', tooltipCoordinate.right)
-                .style('bottom', tooltipCoordinate.bottom)
-                .style('top', tooltipCoordinate.top)
-                .interrupt()
-                .transition()
-                .duration(transition)
-                .ease(easeLinear)
-                .style('left', tooltipCoordinate.left);
-        }
-        else if (chartOrientation === 'horizontal' && tooltipBlock.style('top') !== '0px' && parseInt(tooltipBlock.style('bottom')) > 0 && tooltipCoordinate.bottom === null) {
-            tooltipBlock
-                .style('left', tooltipCoordinate.left)
-                .style('bottom', tooltipCoordinate.bottom)
-                .style('right', tooltipCoordinate.right)
-                .interrupt()
-                .transition()
-                .duration(transition)
-                .ease(easeLinear)
-                .style('top', tooltipCoordinate.top);
-        }
-        else {
-            this.setBlockCoordinate(tooltipBlock, tooltipCoordinate);
-        }
-    }
-}

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

@@ -1,36 +0,0 @@
-import { Selection, BaseType } from 'd3-selection';
-import { MdtChartsDataSource, TooltipHtml } from "../../../config/config";
-import { IntervalChartModel, OptionsModelData, PolarChartModel, TwoDimensionalChartModel } from "../../../model/model";
-import { Size } from "../../../config/config";
-export interface TooltipLineAttributes {
-    x1: number;
-    x2: number;
-    y1: number;
-    y2: number;
-}
-export interface TooltipCoordinate {
-    left: string;
-    top: string;
-    right: string;
-    bottom: string;
-}
-export declare const ARROW_SIZE = 20;
-export declare const ARROW_DEFAULT_POSITION = 9;
-export declare const TOOLTIP_ARROW_PADDING_X: number;
-export declare const TOOLTIP_ARROW_PADDING_Y = 13;
-export declare class TooltipDomHelper {
-    private static readonly groupClass;
-    private static readonly headClass;
-    private static readonly textItemClass;
-    private static readonly maxContentWidth;
-    static fillForMulty2DCharts(contentBlock: Selection<HTMLElement, unknown, BaseType, unknown>, charts: TwoDimensionalChartModel[], data: MdtChartsDataSource, dataOptions: OptionsModelData, keyValue: string, htmlHandler?: TooltipHtml): void;
-    static fillForPolarChart(contentBlock: Selection<HTMLElement, unknown, BaseType, unknown>, chart: PolarChartModel, data: MdtChartsDataSource, dataOptions: OptionsModelData, keyValue: string, markColor: string, htmlHandler?: TooltipHtml): void;
-    static fillForIntervalChart(contentBlock: Selection<HTMLElement, unknown, BaseType, unknown>, charts: IntervalChartModel[], data: MdtChartsDataSource, dataOptions: OptionsModelData, keyValue: string, htmlHandler?: TooltipHtml): void;
-    static getRecalcedCoordinateByArrow(coordinate: [number, number], tooltipBlock: Selection<HTMLElement, unknown, HTMLElement, any>, blockSize: Size, tooltipArrow: Selection<BaseType, unknown, HTMLElement, any>, translateX?: number, translateY?: number): [number, number];
-    private static renderHead;
-    private static fillValuesContent;
-    private static getTooltipItemHtml;
-    private static setTooltipArrowCoordinate;
-    private static fillContentByFunction;
-    private static setWhiteSpaceForTextBlocks;
-}

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

@@ -1,114 +0,0 @@
-import { ValueFormatter, } from "../../valueFormatter";
-import { TooltipHelper } from './tooltipHelper';
-import { Helper } from '../../helpers/helper';
-export const ARROW_SIZE = 20;
-export const ARROW_DEFAULT_POSITION = 9;
-export const TOOLTIP_ARROW_PADDING_X = ARROW_DEFAULT_POSITION - (ARROW_SIZE * Math.sqrt(2) - ARROW_SIZE) / 2 + 14;
-export const TOOLTIP_ARROW_PADDING_Y = 13;
-export class TooltipDomHelper {
-    static fillForMulty2DCharts(contentBlock, charts, data, dataOptions, keyValue, htmlHandler) {
-        contentBlock.html('');
-        if (!htmlHandler) {
-            this.renderHead(contentBlock, keyValue);
-            charts.forEach(chart => {
-                chart.data.valueFields.forEach((field, index) => {
-                    const html = this.getTooltipItemHtml(data, dataOptions, keyValue, field);
-                    this.fillValuesContent(contentBlock, chart.style.elementColors[index % chart.style.elementColors.length], html);
-                });
-            });
-        }
-        else {
-            this.fillContentByFunction(contentBlock, data, dataOptions, keyValue, htmlHandler);
-        }
-    }
-    static fillForPolarChart(contentBlock, chart, data, dataOptions, keyValue, markColor, htmlHandler) {
-        contentBlock.html('');
-        if (!htmlHandler) {
-            this.renderHead(contentBlock, keyValue);
-            const html = this.getTooltipItemHtml(data, dataOptions, keyValue, chart.data.valueField);
-            this.fillValuesContent(contentBlock, markColor, html);
-        }
-        else {
-            this.fillContentByFunction(contentBlock, data, dataOptions, keyValue, htmlHandler);
-        }
-    }
-    static fillForIntervalChart(contentBlock, charts, data, dataOptions, keyValue, htmlHandler) {
-        contentBlock.html('');
-        if (!htmlHandler) {
-            this.renderHead(contentBlock, keyValue);
-            charts.forEach(chart => {
-                let html = this.getTooltipItemHtml(data, dataOptions, keyValue, chart.data.valueField1);
-                this.fillValuesContent(contentBlock, chart.style.elementColors[0 % chart.style.elementColors.length], html);
-                html = this.getTooltipItemHtml(data, dataOptions, keyValue, chart.data.valueField2);
-                this.fillValuesContent(contentBlock, chart.style.elementColors[0 % chart.style.elementColors.length], html);
-            });
-        }
-        else {
-            this.fillContentByFunction(contentBlock, data, dataOptions, keyValue, htmlHandler);
-        }
-    }
-    static getRecalcedCoordinateByArrow(coordinate, tooltipBlock, blockSize, tooltipArrow, translateX = 0, translateY = 0) {
-        const tooltipBlockNode = tooltipBlock.node();
-        const horizontalPad = TooltipHelper.getHorizontalPad(coordinate[0], tooltipBlockNode.getBoundingClientRect().width, blockSize, translateX);
-        const verticalPad = TooltipHelper.getVerticalPad(coordinate[1], tooltipBlockNode.getBoundingClientRect().height, translateY);
-        this.setTooltipArrowCoordinate(tooltipArrow, TooltipHelper.getTooltipArrowPadding(tooltipBlockNode.getBoundingClientRect().width, horizontalPad));
-        return [coordinate[0] - TOOLTIP_ARROW_PADDING_X - horizontalPad,
-            coordinate[1] - TOOLTIP_ARROW_PADDING_Y - tooltipBlockNode.getBoundingClientRect().height - verticalPad];
-    }
-    static renderHead(contentBlock, keyValue) {
-        contentBlock.append('div')
-            .attr('class', `${this.groupClass} ${this.headClass}`)
-            .style('white-space', 'nowrap')
-            .text(keyValue);
-    }
-    static fillValuesContent(contentBlock, markColor, tooltipHtml) {
-        const group = contentBlock.append('div')
-            .attr('class', this.groupClass);
-        if (markColor)
-            group.append('div')
-                .attr('class', 'tooltip-color')
-                .append('span')
-                .attr('class', 'tooltip-circle')
-                .style('background-color', markColor);
-        const textBlock = group.append('div')
-            .attr('class', 'tooltip-texts')
-            .append('div')
-            .attr('class', this.textItemClass)
-            .html(tooltipHtml)
-            .style('white-space', 'nowrap');
-        if (textBlock.node().getBoundingClientRect().width > this.maxContentWidth) {
-            textBlock.style('white-space', 'normal');
-            contentBlock.select(`.${this.headClass}`).style('white-space', 'normal');
-        }
-    }
-    static getTooltipItemHtml(data, dataOptions, keyValue, valueField) {
-        const row = data[dataOptions.dataSource].find(d => d[dataOptions.keyField.name] === keyValue);
-        const text = `<span class="tooltip-field-title">${valueField.title}</span>
-            <span class="tooltip-field-value">${ValueFormatter.formatField(valueField.format, row[valueField.name])}</span>`;
-        return text;
-    }
-    static setTooltipArrowCoordinate(tooltipArrow, horizontalPad) {
-        if (horizontalPad !== 0)
-            tooltipArrow.style('left', `${ARROW_DEFAULT_POSITION + Math.floor(horizontalPad)}px`);
-        else
-            tooltipArrow.style('left', `${ARROW_DEFAULT_POSITION}px`);
-    }
-    static fillContentByFunction(contentBlock, data, dataOptions, keyValue, htmlHandler) {
-        const row = Helper.getRowsByKeys([keyValue], dataOptions.keyField.name, data[dataOptions.dataSource])[0];
-        contentBlock.html(htmlHandler(row));
-        this.setWhiteSpaceForTextBlocks(contentBlock);
-        contentBlock.selectAll('.tooltip-text-item').style('display', 'block');
-    }
-    static setWhiteSpaceForTextBlocks(contentBlock) {
-        contentBlock.style('min-width', null);
-        contentBlock.selectAll(`.${this.textItemClass}`).style('white-space', 'pre');
-        if (contentBlock.node().getBoundingClientRect().width > this.maxContentWidth) {
-            contentBlock.selectAll(`.${this.textItemClass}`).style('white-space', 'pre-wrap');
-            contentBlock.style('min-width', this.maxContentWidth + 'px');
-        }
-    }
-}
-TooltipDomHelper.groupClass = 'tooltip-group';
-TooltipDomHelper.headClass = 'tooltip-head';
-TooltipDomHelper.textItemClass = 'tooltip-text-item';
-TooltipDomHelper.maxContentWidth = 500;

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

@@ -1,16 +0,0 @@
-import { AxisScale } from "d3-axis";
-import { ChartOrientation } from "../../../config/config";
-import { BlockMargin, Orient } from "../../../model/model";
-import { TooltipCoordinate, TooltipLineAttributes } from "./tooltipDomHelper";
-import { Size } from "../../../config/config";
-export declare class TooltipHelper {
-    private static convexsize;
-    static getHorizontalPad(coordinateX: number, tooltipBlockWidth: number, blockSize: Size, translateX: number): number;
-    static getVerticalPad(coordinateY: number, tooltipBlockHeight: number, translateY: number): number;
-    static getTooltipArrowPadding(tooltipBlockWidth: number, horizontalPad: number): number;
-    static getCoordinateByPointer(pointer: [number, number]): TooltipCoordinate;
-    static getTooltipFixedCoordinate(scaleKey: AxisScale<any>, margin: BlockMargin, keyValue: string, blockBoundingRect: DOMRect, tooltipBoundingRect: DOMRect, keyAxisOrient: Orient, winWidth: number, winHeight: number): TooltipCoordinate;
-    static getTooltipCursorCoordinate(pointer: [number, number], blockBoundingRect: DOMRect, tooltipBoundingRect: DOMRect, winWidth: number, winHeight: number): TooltipCoordinate;
-    static getTooltipLineAttributes(scaleKey: AxisScale<any>, margin: BlockMargin, key: string, chartOrientation: ChartOrientation, blockSize: Size): TooltipLineAttributes;
-    static recalcToolTipCoordinateByViewPort(blockBounding: DOMRect, tooltipBounding: DOMRect, coordinate: TooltipCoordinate, winWidth: number, winHeight: number): TooltipCoordinate;
-}

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

@@ -1,99 +0,0 @@
-import { Helper } from "../../helpers/helper";
-import { Scale } from "../scale/scale";
-import { ARROW_DEFAULT_POSITION, TOOLTIP_ARROW_PADDING_X, TOOLTIP_ARROW_PADDING_Y } from "./tooltipDomHelper";
-export class TooltipHelper {
-    static getHorizontalPad(coordinateX, tooltipBlockWidth, blockSize, translateX) {
-        let pad = 0;
-        if (tooltipBlockWidth + coordinateX - TOOLTIP_ARROW_PADDING_X + translateX > blockSize.width)
-            pad = tooltipBlockWidth + coordinateX - TOOLTIP_ARROW_PADDING_X + translateX - blockSize.width;
-        return pad;
-    }
-    static getVerticalPad(coordinateY, tooltipBlockHeight, translateY) {
-        let pad = 0;
-        if (coordinateY - TOOLTIP_ARROW_PADDING_Y - tooltipBlockHeight + translateY < -tooltipBlockHeight - TOOLTIP_ARROW_PADDING_Y)
-            pad = coordinateY;
-        return pad; // return zero or sub zero
-    }
-    static getTooltipArrowPadding(tooltipBlockWidth, horizontalPad) {
-        return horizontalPad > tooltipBlockWidth
-            ? tooltipBlockWidth - ARROW_DEFAULT_POSITION - 20 * Math.sqrt(2)
-            : horizontalPad; // If tooltip arrow has coordinate outside svg, it take X position in end of tooltip block
-    }
-    static getCoordinateByPointer(pointer) {
-        const coordinate = {
-            left: null,
-            top: null,
-            right: null,
-            bottom: null
-        };
-        coordinate.left = pointer[0] + 'px';
-        coordinate.top = pointer[1] + 'px';
-        return coordinate;
-    }
-    static getTooltipFixedCoordinate(scaleKey, margin, keyValue, blockBoundingRect, tooltipBoundingRect, keyAxisOrient, winWidth, winHeight) {
-        const coordinate = {
-            top: null,
-            bottom: null,
-            left: null,
-            right: null
-        };
-        if (keyAxisOrient === 'bottom' || keyAxisOrient === 'top') {
-            coordinate.left = Scale.getScaledValue(scaleKey, keyValue) + margin.left - tooltipBoundingRect.width / 2 + 'px';
-            if (keyAxisOrient === 'bottom')
-                coordinate.top = margin.top - 5 - tooltipBoundingRect.height + 'px';
-            else
-                coordinate.top = blockBoundingRect.height - margin.bottom + 'px';
-        }
-        if (keyAxisOrient === 'left' || keyAxisOrient === 'right') {
-            coordinate.top = Scale.getScaledValue(scaleKey, keyValue) + margin.top - tooltipBoundingRect.height / 2 + 'px';
-            if (keyAxisOrient === 'left')
-                coordinate.left = blockBoundingRect.width - margin.right + 'px';
-            else
-                coordinate.left = margin.left - tooltipBoundingRect.width + 'px';
-        }
-        return this.recalcToolTipCoordinateByViewPort(blockBoundingRect, tooltipBoundingRect, coordinate, winWidth, winHeight);
-    }
-    static getTooltipCursorCoordinate(pointer, blockBoundingRect, tooltipBoundingRect, winWidth, winHeight) {
-        const pad = 10;
-        const coordinate = {
-            top: pointer[1] + pad + 'px',
-            bottom: null,
-            left: pointer[0] + pad + 'px',
-            right: null
-        };
-        return this.recalcToolTipCoordinateByViewPort(blockBoundingRect, tooltipBoundingRect, coordinate, winWidth, winHeight);
-    }
-    static getTooltipLineAttributes(scaleKey, margin, key, chartOrientation, blockSize) {
-        const attributes = {
-            x1: 0, x2: 0, y1: 0, y2: 0
-        };
-        if (chartOrientation === 'vertical') {
-            attributes.x1 = Math.ceil(Scale.getScaledValue(scaleKey, key) + margin.left) - 0.5;
-            attributes.x2 = Math.ceil(Scale.getScaledValue(scaleKey, key) + margin.left) - 0.5;
-            attributes.y1 = margin.top - this.convexsize;
-            attributes.y2 = blockSize.height - margin.bottom + this.convexsize * 2;
-        }
-        else {
-            attributes.x1 = margin.left - this.convexsize;
-            attributes.x2 = blockSize.width - margin.right + this.convexsize * 2;
-            attributes.y1 = Scale.getScaledValue(scaleKey, key) + margin.top;
-            attributes.y2 = Scale.getScaledValue(scaleKey, key) + margin.top;
-        }
-        return attributes;
-    }
-    static recalcToolTipCoordinateByViewPort(blockBounding, tooltipBounding, coordinate, winWidth, winHeight) {
-        const scrollPad = 18;
-        const tooltipLeftAtBlock = Helper.getPXValueFromString(coordinate.left);
-        if (tooltipLeftAtBlock < 0 && -tooltipLeftAtBlock > blockBounding.left)
-            coordinate.left = -blockBounding.left + 'px';
-        if (blockBounding.left + tooltipLeftAtBlock + tooltipBounding.width > winWidth - scrollPad)
-            coordinate.left = winWidth - blockBounding.left - tooltipBounding.width - scrollPad + 'px';
-        const tooltipTopAtBlock = Helper.getPXValueFromString(coordinate.top);
-        if (tooltipTopAtBlock + blockBounding.top < 0 && -tooltipTopAtBlock > blockBounding.top)
-            coordinate.top = -blockBounding.top + 'px';
-        if (blockBounding.top + tooltipTopAtBlock + tooltipBounding.height > winHeight)
-            coordinate.top = blockBounding.height - tooltipBounding.height - (blockBounding.bottom - winHeight) + 'px';
-        return coordinate;
-    }
-}
-TooltipHelper.convexsize = 5;

package/lib/engine/filterManager/filterEventManager.d.ts

@@ -1,33 +0,0 @@
-import { AxisScale } from "d3-axis";
-import { MdtChartsDataRow, Size } from "../../config/config";
-import { BlockMargin, TwoDimensionalOptionsModel, PolarOptionsModel, DonutChartSettings } from "../../model/model";
-import { Block } from "../block/block";
-export declare type FilterCallback = (rows: MdtChartsDataRow[]) => void;
-export interface SelectDetails {
-    multySelect: boolean;
-    keyValue?: string;
-}
-export declare class FilterEventManager {
-    private callback;
-    private fullDataset;
-    private filterable;
-    private block;
-    private selectedKeys;
-    constructor(callback: FilterCallback, fullDataset: MdtChartsDataRow[], filtrable: boolean, keyFieldName: string, selectedIds?: number[]);
-    setBlock(block: Block): void;
-    getSelectedKeys(): string[];
-    updateData(newDataset: MdtChartsDataRow[]): void;
-    isSelected(keyValue: string): boolean;
-    clearKeysFor2D(options: TwoDimensionalOptionsModel): void;
-    clearKeysForPolar(margin: BlockMargin, blockSize: Size, options: PolarOptionsModel, donutSettings: DonutChartSettings): void;
-    private setKey;
-    private addId;
-    private removeId;
-    private processKey;
-    setListenerPolar(margin: BlockMargin, blockSize: Size, options: PolarOptionsModel, donutSettings: DonutChartSettings): void;
-    event2DUpdate(options: TwoDimensionalOptionsModel): void;
-    registerEventFor2D(scaleKey: AxisScale<any>, margin: BlockMargin, blockSize: Size, options: TwoDimensionalOptionsModel): void;
-    private registerEventToDonut;
-    private getMultyParamByEvent;
-    private getMultySelectParam;
-}

package/lib/engine/filterManager/filterEventManager.js

@@ -1,127 +0,0 @@
-import { pointer, select } from "d3-selection";
-import { SelectHighlighter } from "../elementHighlighter/selectHighlighter";
-import { TipBox } from "../features/tipBox/tipBox";
-import { TipBoxHelper } from "../features/tipBox/tipBoxHelper";
-import { Helper } from "../helpers/helper";
-import { Donut } from "../polarNotation/donut/donut";
-export class FilterEventManager {
-    constructor(callback, fullDataset, filtrable, keyFieldName, selectedIds = []) {
-        this.callback = callback;
-        this.fullDataset = fullDataset;
-        this.selectedKeys = Helper.getKeysByIds(selectedIds, keyFieldName, fullDataset);
-        this.filterable = filtrable;
-    }
-    setBlock(block) {
-        this.block = block;
-    }
-    getSelectedKeys() {
-        return this.selectedKeys;
-    }
-    updateData(newDataset) {
-        this.fullDataset = newDataset;
-    }
-    isSelected(keyValue) {
-        return this.selectedKeys.findIndex(key => key === keyValue) !== -1;
-    }
-    clearKeysFor2D(options) {
-        this.selectedKeys = [];
-        if (this.callback)
-            this.callback([]);
-        SelectHighlighter.clear2D(this.block, options);
-    }
-    clearKeysForPolar(margin, blockSize, options, donutSettings) {
-        this.selectedKeys = [];
-        if (this.callback)
-            this.callback([]);
-        SelectHighlighter.clearPolar(margin, blockSize, this.block, options, Donut.getAllArcGroups(this.block), donutSettings);
-    }
-    setKey(key) {
-        this.selectedKeys = [key];
-    }
-    addId(key) {
-        this.selectedKeys.push(key);
-    }
-    removeId(key) {
-        this.selectedKeys.splice(this.selectedKeys.findIndex(k => k === key), 1);
-    }
-    processKey(multySelect, keyValue) {
-        if (multySelect) {
-            if (this.getSelectedKeys().findIndex(key => key === keyValue) === -1) {
-                this.addId(keyValue);
-                return true;
-            }
-            else {
-                this.removeId(keyValue);
-                return false;
-            }
-        }
-        else {
-            if (this.getSelectedKeys()[0] === keyValue && this.getSelectedKeys().length === 1) {
-                this.removeId(keyValue);
-                return false;
-            }
-            else {
-                this.setKey(keyValue);
-                return true;
-            }
-        }
-    }
-    setListenerPolar(margin, blockSize, options, donutSettings) {
-        if (this.filterable) {
-            this.registerEventToDonut(margin, blockSize, options, donutSettings);
-            const selectedElems = Donut.getAllArcGroups(this.block).filter(d => this.selectedKeys.findIndex(sid => sid === d.data[options.data.keyField.name]) !== -1);
-            this.selectedKeys = [];
-            selectedElems.dispatch('click', { bubbles: false, cancelable: true, detail: { multySelect: true } });
-        }
-    }
-    event2DUpdate(options) {
-        if (this.filterable) {
-            const removedKeys = [];
-            this.selectedKeys.forEach(key => {
-                if (this.fullDataset.findIndex(row => row[options.data.keyField.name] === key) === -1)
-                    removedKeys.push(key);
-            });
-            removedKeys.forEach(rKey => this.selectedKeys.splice(this.selectedKeys.findIndex(sKey => sKey === rKey), 1));
-            this.selectedKeys.forEach(key => {
-                SelectHighlighter.click2DHandler(true, true, key, this.selectedKeys, this.block, options);
-            });
-        }
-    }
-    registerEventFor2D(scaleKey, margin, blockSize, options) {
-        if (this.filterable) {
-            const tipBox = TipBox.renderOrGet(this.block, margin, blockSize);
-            const thisClass = this;
-            tipBox.on('click', function (e) {
-                const multySelect = thisClass.getMultySelectParam(e);
-                const keyValue = e.detail.keyValue || TipBoxHelper.getKeyValueByPointer(pointer(e, this), options.orient, margin, blockSize, scaleKey, options.scale.key.type);
-                const appended = thisClass.processKey(multySelect, keyValue);
-                SelectHighlighter.click2DHandler(multySelect, appended, keyValue, thisClass.selectedKeys, thisClass.block, options);
-                if (thisClass.callback) {
-                    thisClass.callback(Helper.getRowsByKeys(thisClass.selectedKeys, options.data.keyField.name, thisClass.fullDataset));
-                }
-            });
-        }
-    }
-    registerEventToDonut(margin, blockSize, options, donutSettings) {
-        const arcItems = Donut.getAllArcGroups(this.block);
-        const thisClass = this;
-        arcItems.on('click', function (e, dataRow) {
-            const multySelect = thisClass.getMultySelectParam(e);
-            const keyValue = dataRow.data[options.data.keyField.name];
-            const appended = thisClass.processKey(multySelect, keyValue);
-            SelectHighlighter.clickPolarHandler(multySelect, appended, select(this), thisClass.getSelectedKeys(), margin, blockSize, thisClass.block, options, arcItems, donutSettings);
-            if (thisClass.callback) {
-                thisClass.callback(Helper.getRowsByKeys(thisClass.selectedKeys, options.data.keyField.name, thisClass.fullDataset));
-            }
-        });
-    }
-    getMultyParamByEvent(e) {
-        return e.ctrlKey || e.metaKey;
-    }
-    getMultySelectParam(e) {
-        const isMultyButtonToggle = this.getMultyParamByEvent(e);
-        return isMultyButtonToggle === undefined
-            ? (e.detail.multySelect === undefined ? false : e.detail.multySelect)
-            : isMultyButtonToggle;
-    }
-}

package/lib/engine/helpers/domHelper.d.ts

@@ -1,30 +0,0 @@
-import { Selection, BaseType } from 'd3-selection';
-import { MdtChartsDataRow } from '../../config/config';
-import { ChartStyle, TwoDimensionalChartModel } from "../../model/model";
-import { Block } from "../block/block";
-declare type StyleColorType = 'fill' | 'stroke';
-export declare enum SelectionCondition {
-    Include = 0,
-    Exclude = 1
-}
-export declare class DomHelper {
-    static setCssClasses(elem: Selection<BaseType, unknown, any, unknown>, cssClasses: string[]): void;
-    static get2DChartElements(block: Block, chart: TwoDimensionalChartModel): Selection<BaseType, MdtChartsDataRow, BaseType, unknown>;
-    static getCssPropertyValue(node: Element, propertyName: string): string;
-    static getSelectionNumericAttr(selection: Selection<BaseType, unknown, BaseType, unknown>, attrName: string): number;
-    static setChartStyle(elements: Selection<BaseType, unknown, BaseType, unknown>, chartStyle: ChartStyle, fieldIndex: number, styleType: StyleColorType): void;
-    static setChartElementColor(elements: Selection<BaseType, unknown, BaseType, unknown>, colorPalette: string[], fieldIndex: number, styleType: StyleColorType): void;
-    static cropSvgLabels(labelBlocks: Selection<SVGGraphicsElement, unknown, BaseType, unknown>, maxWidth: number): void;
-    /**
-     * Возвращает выборку элементов, ключи которых содержатся или НЕ содержатся в переданном массиве
-     * @param initialSelection Изначальная выборка
-     * @param dataWrapped Содержаться ли данные в обертке .data
-     * @param keyFieldName название поля ключей
-     * @param keyValues значения ключей
-     * @param condition включать или исключать элменты по ключам
-     * @returns Выборка по ключам
-     */
-    static getChartElementsByKeys<T extends BaseType>(initialSelection: Selection<T, MdtChartsDataRow, BaseType, unknown>, dataWrapped: boolean, keyFieldName: string, keyValues: string[], condition?: SelectionCondition): Selection<T, any, BaseType, unknown>;
-    private static setChartOpacity;
-}
-export {};

package/lib/engine/helpers/domHelper.js

@@ -1,68 +0,0 @@
-import { MarkDot } from "../features/markDots/markDot";
-import { Bar } from "../twoDimensionalNotation/bar/bar";
-export var SelectionCondition;
-(function (SelectionCondition) {
-    SelectionCondition[SelectionCondition["Include"] = 0] = "Include";
-    SelectionCondition[SelectionCondition["Exclude"] = 1] = "Exclude";
-})(SelectionCondition || (SelectionCondition = {}));
-export class DomHelper {
-    static setCssClasses(elem, cssClasses) {
-        cssClasses.forEach(cssClass => {
-            elem.classed(cssClass, true);
-        });
-    }
-    static get2DChartElements(block, chart) {
-        if (chart.type === 'line' || chart.type === 'area')
-            return MarkDot.getMarkDotForChart(block, chart.cssClasses);
-        else
-            return Bar.getAllBarsForChart(block, chart.cssClasses);
-    }
-    static getCssPropertyValue(node, propertyName) {
-        return window.getComputedStyle(node).getPropertyValue(propertyName);
-    }
-    static getSelectionNumericAttr(selection, attrName) {
-        return parseFloat(selection.attr(attrName));
-    }
-    static setChartStyle(elements, chartStyle, fieldIndex, styleType) {
-        this.setChartElementColor(elements, chartStyle.elementColors, fieldIndex, styleType);
-        this.setChartOpacity(elements, chartStyle.opacity);
-    }
-    static setChartElementColor(elements, colorPalette, fieldIndex, styleType) {
-        elements.style(styleType, colorPalette[fieldIndex % colorPalette.length]);
-    }
-    static cropSvgLabels(labelBlocks, maxWidth) {
-        labelBlocks.nodes().forEach(node => {
-            if (node.getBBox().width > maxWidth) {
-                const text = node.textContent;
-                let textLength = text.length;
-                while (node.getBBox().width > maxWidth && textLength > 0) {
-                    node.textContent = text.substring(0, --textLength) + '...';
-                }
-                if (textLength === 0)
-                    node.textContent = '';
-            }
-        });
-    }
-    /**
-     * Возвращает выборку элементов, ключи которых содержатся или НЕ содержатся в переданном массиве
-     * @param initialSelection Изначальная выборка
-     * @param dataWrapped Содержаться ли данные в обертке .data
-     * @param keyFieldName название поля ключей
-     * @param keyValues значения ключей
-     * @param condition включать или исключать элменты по ключам
-     * @returns Выборка по ключам
-     */
-    static getChartElementsByKeys(initialSelection, dataWrapped, keyFieldName, keyValues, condition = SelectionCondition.Include) {
-        return initialSelection.filter(d => {
-            let i;
-            if (dataWrapped)
-                i = keyValues.findIndex(kv => kv === d.data[keyFieldName]);
-            else
-                i = keyValues.findIndex(kv => kv === d[keyFieldName]);
-            return condition === SelectionCondition.Exclude ? i === -1 : i !== -1;
-        });
-    }
-    static setChartOpacity(elements, opacity) {
-        elements.attr('opacity', opacity);
-    }
-}