mdt-charts 1.9.7 → 1.9.11

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

@@ -1,11 +0,0 @@
-import { Size } from "../../../config/config";
-import { BlockMargin, GridLineFlag, IAxisModel, ScaleKeyModel } from "../../../model/model";
-import { Block } from "../../block/block";
-export declare class GridLine {
-    private static readonly gridLineClass;
-    static render(block: Block, gridLineFlag: GridLineFlag, axes: IAxisModel, blockSize: Size, margin: BlockMargin, scaleKey: ScaleKeyModel): void;
-    static update(block: Block, gridLineFlag: GridLineFlag, axes: IAxisModel, blockSize: Size, margin: BlockMargin, scaleKey: ScaleKeyModel): void;
-    private static renderLine;
-    private static clear;
-    private static removeGridLinesOnAxes;
-}

package/lib/engine/features/gridLine/gridLine.js

@@ -1,67 +0,0 @@
-import { GridLineHelper } from "./gidLineHelper";
-export class GridLine {
-    static render(block, gridLineFlag, axes, blockSize, margin, scaleKey) {
-        if (gridLineFlag.value) {
-            const lineLength = GridLineHelper.getGridLineLength('value', axes.key, axes.value, blockSize, margin);
-            const lineAttributes = GridLineHelper.getLineAttributes(axes.value, lineLength);
-            this.renderLine(block, axes.value, lineAttributes);
-        }
-        if (gridLineFlag.key) {
-            const lineLength = GridLineHelper.getGridLineLength('key', axes.key, axes.value, blockSize, margin);
-            const lineAttributes = GridLineHelper.getLineAttributes(axes.key, lineLength);
-            this.renderLine(block, axes.key, lineAttributes);
-        }
-        if (scaleKey.type === 'point' && (gridLineFlag.key || gridLineFlag.value))
-            this.removeGridLinesOnAxes(block, axes.key, axes.value, false);
-        else if (gridLineFlag.key || gridLineFlag.value)
-            this.removeGridLinesOnAxes(block, axes.key, axes.value, true);
-    }
-    static update(block, gridLineFlag, axes, blockSize, margin, scaleKey) {
-        this.clear(block, axes.key.cssClass, axes.value.cssClass);
-        this.render(block, gridLineFlag, axes, blockSize, margin, scaleKey);
-    }
-    static renderLine(block, axis, lineAttributes) {
-        block
-            .getSvg()
-            .selectAll(`.${axis.cssClass}`)
-            .selectAll('g.tick')
-            .append('line')
-            .attr('class', this.gridLineClass)
-            .attr('x1', lineAttributes.x1)
-            .attr('y1', lineAttributes.y1)
-            .attr('x2', lineAttributes.x2)
-            .attr('y2', lineAttributes.y2);
-    }
-    static clear(block, keyAxisClass, valueAxisClass) {
-        block.getSvg()
-            .selectAll(`.${keyAxisClass} `)
-            .selectAll('g.tick')
-            .selectAll(`.${this.gridLineClass}`)
-            .remove();
-        block.getSvg()
-            .selectAll(`.${valueAxisClass}`)
-            .selectAll('g.tick')
-            .selectAll(`.${this.gridLineClass}`)
-            .remove();
-    }
-    static removeGridLinesOnAxes(block, keyAxis, valueAxis, excludeKey) {
-        let tickOnKeyAxisSelector = '';
-        let tickOnValueAxisSelector = '';
-        if (valueAxis.orient === 'right' || valueAxis.orient === 'bottom')
-            tickOnValueAxisSelector = ':last-of-type';
-        if (keyAxis.orient === 'bottom' || keyAxis.orient === 'right')
-            tickOnKeyAxisSelector = ':last-of-type';
-        block.getSvg()
-            .select(`.${valueAxis.cssClass}`)
-            .select(`g.tick${tickOnKeyAxisSelector}`)
-            .select(`.${this.gridLineClass}`)
-            .remove();
-        if (!excludeKey)
-            block.getSvg()
-                .select(`.${keyAxis.cssClass}`)
-                .select(`g.tick${tickOnValueAxisSelector}`)
-                .select(`.${this.gridLineClass}`)
-                .remove();
-    }
-}
-GridLine.gridLineClass = 'grid-line';

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

@@ -1,22 +0,0 @@
-import { BaseType, Selection } from "d3-selection";
-import { MdtChartsDataSource } from "../../../config/config";
-import { IntervalOptionsModel, Model, PolarOptionsModel, TwoDimensionalOptionsModel } from "../../../model/model";
-import { Block } from "../../block/block";
-import { SelectionCondition } from "../../helpers/domHelper";
-export declare class Legend {
-    static readonly objectClass = "legend-object";
-    static readonly labelClass = "legend-label";
-    static readonly itemClass = "legend-item";
-    static readonly markerClass = "legend-circle";
-    private static readonly legendBlockClass;
-    static render(block: Block, data: MdtChartsDataSource, options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel, model: Model): void;
-    static update(block: Block, data: MdtChartsDataSource, model: Model): void;
-    static updateColors(block: Block, options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel): void;
-    static getItemsByKeys(block: Block, keys: string[], condition?: SelectionCondition): Selection<HTMLDivElement, string, BaseType, unknown>;
-    private static setContent;
-    private static renderObject;
-    private static renderContent;
-    private static getObject;
-    private static removeContent;
-    private static fillCoordinate;
-}

package/lib/engine/features/legend/legend.js

@@ -1,109 +0,0 @@
-import { select } from "d3-selection";
-import { SelectionCondition } from "../../helpers/domHelper";
-import { LegendDomHelper } from "./legendDomHelper";
-import { LegendEventsManager } from "./legendEventsManager";
-import { LegendHelper } from "./legendHelper";
-export class Legend {
-    static render(block, data, options, model) {
-        if (options.legend.position !== 'off') {
-            const legendObject = this.renderObject(block, options.legend.position, model.otherComponents.legendBlock, model.blockCanvas.size);
-            this.setContent(block, data, options, legendObject);
-        }
-    }
-    static update(block, data, model) {
-        if (model.options.legend.position !== 'off') {
-            const legendObject = this.getObject(block);
-            const legendCoordinate = LegendHelper.getLegendCoordinateByPosition(model.options.legend.position, model.otherComponents.legendBlock, model.blockCanvas.size);
-            this.fillCoordinate(legendObject, legendCoordinate);
-            this.removeContent(legendObject);
-            this.setContent(block, data, model.options, legendObject);
-        }
-    }
-    static updateColors(block, options) {
-        const legendObject = this.getObject(block);
-        const colors = LegendHelper.getMarksColor(options);
-        const itemWrappers = legendObject
-            .selectAll(`.${this.itemClass}`);
-        LegendDomHelper.setItemsColors(itemWrappers, colors);
-    }
-    static getItemsByKeys(block, keys, condition = SelectionCondition.Include) {
-        return block
-            .getSvg()
-            .selectAll(`.${this.itemClass}`)
-            .filter(d => {
-            const index = keys.findIndex(k => k === d);
-            return condition === SelectionCondition.Include ? index !== -1 : index === -1;
-        });
-    }
-    static setContent(block, data, options, legendObject) {
-        const items = LegendHelper.getLegendItemsContent(options, data);
-        const colors = LegendHelper.getMarksColor(options);
-        const itemsDirection = LegendHelper.getLegendItemsDirection(options.type, options.legend.position);
-        const itemBlocks = this.renderContent(legendObject, items, colors, itemsDirection, options.legend.position);
-        if (options.type === 'polar') {
-            LegendEventsManager.setListeners(block, options.data.keyField.name, itemBlocks, options.selectable);
-        }
-        else {
-            LegendDomHelper.setItemsTitles(itemBlocks);
-        }
-    }
-    static renderObject(block, legendPosition, legendBlockModel, blockSize) {
-        const legendObject = block.getSvg()
-            .append('foreignObject')
-            .attr('class', Legend.objectClass);
-        const legendCoordinate = LegendHelper.getLegendCoordinateByPosition(legendPosition, legendBlockModel, blockSize);
-        this.fillCoordinate(legendObject, legendCoordinate);
-        return legendObject;
-    }
-    static renderContent(legendObject, items, colorPalette, itemsDirection, position) {
-        const wrapper = legendObject.append('xhtml:div')
-            .attr('class', Legend.legendBlockClass);
-        wrapper
-            .style('height', '100%')
-            .style('display', 'flex');
-        if (itemsDirection === 'column') {
-            wrapper.style('flex-direction', 'column');
-            if (position === 'right')
-                wrapper.style('justify-content', 'center');
-        }
-        const itemWrappers = wrapper
-            .selectAll(`.${this.itemClass}`)
-            .data(items)
-            .enter()
-            .append('div');
-        const thisClass = this;
-        itemWrappers.each(function (d, i) {
-            select(this).attr('class', `${thisClass.itemClass} ${LegendHelper.getItemClasses(itemsDirection, position, i)}`);
-        });
-        itemWrappers
-            .append('span')
-            .attr('class', this.markerClass);
-        LegendDomHelper.setItemsColors(itemWrappers, colorPalette);
-        itemWrappers
-            .append('span')
-            .attr('class', LegendHelper.getLegendLabelClassByPosition(position))
-            .text(d => d);
-        if (itemsDirection === 'row')
-            LegendDomHelper.cropRowLabels(legendObject, itemWrappers);
-        return itemWrappers;
-    }
-    static getObject(block) {
-        return block.getSvg()
-            .select(`foreignObject.${Legend.objectClass}`);
-    }
-    static removeContent(legendObject) {
-        legendObject.select(`.${Legend.legendBlockClass}`).remove();
-    }
-    static fillCoordinate(legendBlock, coordinate) {
-        legendBlock
-            .attr('x', coordinate.x)
-            .attr('y', coordinate.y)
-            .attr('width', coordinate.width)
-            .attr('height', coordinate.height);
-    }
-}
-Legend.objectClass = 'legend-object';
-Legend.labelClass = 'legend-label';
-Legend.itemClass = 'legend-item';
-Legend.markerClass = 'legend-circle';
-Legend.legendBlockClass = 'legend-block';

package/lib/engine/features/legend/legendDomHelper.d.ts

@@ -1,8 +0,0 @@
-import { BaseType, Selection } from "d3-selection";
-export declare class LegendDomHelper {
-    static setItemsTitles(items: Selection<HTMLDivElement, string, BaseType, unknown>): void;
-    static setItemsColors(items: Selection<HTMLDivElement, string, BaseType, unknown>, colorPalette: string[]): void;
-    static cropRowLabels(legendBlock: Selection<SVGForeignObjectElement, unknown, HTMLElement, any>, items: Selection<HTMLDivElement, string, BaseType, unknown>): void;
-    private static getItemsLeftMargins;
-    private static getItemsWidth;
-}

package/lib/engine/features/legend/legendDomHelper.js

@@ -1,48 +0,0 @@
-import { DomHelper } from "../../helpers/domHelper";
-import { Helper } from "../../helpers/helper";
-import { Legend } from "./legend";
-import { LegendHelper } from "./legendHelper";
-export class LegendDomHelper {
-    static setItemsTitles(items) {
-        items.attr('title', d => d);
-    }
-    static setItemsColors(items, colorPalette) {
-        items.select(`.${Legend.markerClass}`)
-            .style('background-color', (d, i) => colorPalette[i % colorPalette.length]);
-    }
-    static cropRowLabels(legendBlock, items) {
-        const maxWidth = legendBlock.node().getBoundingClientRect().width;
-        let itemsLeftMargins = this.getItemsLeftMargins(items);
-        let itemsWidth = this.getItemsWidth(items);
-        let sumOfItemsWidth = LegendHelper.getSumOfItemsWidths(itemsWidth, itemsLeftMargins);
-        const maxItemWidth = LegendHelper.getMaxItemWidth(legendBlock.attr('width'), itemsLeftMargins, 'row');
-        let index = 0;
-        let loopFlag = true; // if at least one label has no text, loop ends
-        while (sumOfItemsWidth > maxWidth && loopFlag) {
-            items.nodes().forEach(node => {
-                const textBlock = node.querySelector(`.${Legend.labelClass}`);
-                if (node.getBoundingClientRect().width > maxItemWidth && textBlock.textContent) {
-                    let labelText = index > 0
-                        ? textBlock.textContent.substr(0, textBlock.textContent.length - 3)
-                        : textBlock.textContent;
-                    labelText = labelText.substr(0, labelText.length - 1);
-                    textBlock.textContent = labelText + '...';
-                    itemsLeftMargins = this.getItemsLeftMargins(items);
-                    itemsWidth = this.getItemsWidth(items);
-                    sumOfItemsWidth = LegendHelper.getSumOfItemsWidths(itemsWidth, itemsLeftMargins);
-                    if (labelText.length === 0) {
-                        textBlock.textContent = '';
-                        loopFlag = false;
-                    }
-                }
-            });
-            index++;
-        }
-    }
-    static getItemsLeftMargins(items) {
-        return items.nodes().map(node => Helper.getPXValueFromString(DomHelper.getCssPropertyValue(node, 'margin-left')));
-    }
-    static getItemsWidth(items) {
-        return items.nodes().map(node => node.getBoundingClientRect().width);
-    }
-}

package/lib/engine/features/legend/legendEventsManager.d.ts

@@ -1,12 +0,0 @@
-import { BaseType, Selection } from "d3-selection";
-import { Block } from "../../block/block";
-export declare class LegendEventsManager {
-    /**
-     * @param block
-     * @param keyFieldName
-     * @param legendItems айтемы легенды полара, которые привязаны к ключам
-     */
-    static setListeners(block: Block, keyFieldName: string, legendItems: Selection<HTMLDivElement, string, BaseType, unknown>, selectable: boolean): void;
-    private static setHoverListeners;
-    private static setClickListeners;
-}

package/lib/engine/features/legend/legendEventsManager.js

@@ -1,47 +0,0 @@
-import { pointer, select } from "d3-selection";
-import { ElementHighlighter } from "../../elementHighlighter/elementHighlighter";
-import { Donut } from "../../polarNotation/donut/donut";
-export class LegendEventsManager {
-    /**
-     * @param block
-     * @param keyFieldName
-     * @param legendItems айтемы легенды полара, которые привязаны к ключам
-     */
-    static setListeners(block, keyFieldName, legendItems, selectable) {
-        this.setHoverListeners(block, keyFieldName, legendItems);
-        if (selectable)
-            this.setClickListeners(block, keyFieldName, legendItems);
-    }
-    static setHoverListeners(block, keyFieldName, legendItems) {
-        const arcItems = Donut.getAllArcGroups(block);
-        legendItems.on('mousemove', function (e, keyValue) {
-            arcItems.filter((row) => row.data[keyFieldName] === keyValue)
-                .dispatch('mousemove', {
-                bubbles: false,
-                cancelable: true,
-                detail: {
-                    pointer: pointer(e, block.getWrapper().node()),
-                    ignoreTranslate: true
-                }
-            });
-        });
-        legendItems.on('mouseover', function (e, keyValue) {
-            arcItems.filter((row) => row.data[keyFieldName] === keyValue)
-                .dispatch('mouseover');
-            ElementHighlighter.toggleActivityStyle(select(this), true);
-        });
-        legendItems.on('mouseleave', function (e, keyValue) {
-            arcItems.filter((row) => row.data[keyFieldName] === keyValue)
-                .dispatch('mouseleave');
-            if (!block.filterEventManager.isSelected(keyValue) && block.filterEventManager.getSelectedKeys().length > 0)
-                ElementHighlighter.toggleActivityStyle(select(this), false);
-        });
-    }
-    static setClickListeners(block, keyFieldName, legendItems) {
-        const arcItems = Donut.getAllArcGroups(block);
-        legendItems.on('click', (e, keyValue) => {
-            arcItems.filter((row) => row.data[keyFieldName] === keyValue)
-                .dispatch('click', { bubbles: false, cancelable: true, detail: { multySelect: e.ctrlKey || e.metaKey } });
-        });
-    }
-}

package/lib/engine/features/legend/legendHelper.d.ts

@@ -1,21 +0,0 @@
-import { ChartNotation, MdtChartsDataSource, Size } from "../../../config/config";
-import { LegendItemsDirection } from "../../../model/featuresModel/legendModel/legendCanvasModel";
-import { IntervalOptionsModel, LegendBlockModel, LegendPosition, Orient, PolarOptionsModel, TwoDimensionalOptionsModel } from "../../../model/model";
-export interface LegendCoordinate {
-    x: number;
-    y: number;
-    height: number;
-    width: number;
-}
-export declare class LegendHelper {
-    static getLegendItemsContent(options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel, data: MdtChartsDataSource): string[];
-    static getMarksColor(options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel): string[];
-    static getMaxItemWidth(legendBlockWidth: string, marginsLeft: number[], itemsDirection: LegendItemsDirection): number;
-    static getItemClasses(itemsDirection: LegendItemsDirection, position: LegendPosition, index: number): string;
-    static getLegendItemClassByDirection(itemsDirection: LegendItemsDirection): string;
-    static getLegendItemsMarginClass(legendPosition: LegendPosition): string;
-    static getLegendLabelClassByPosition(position: LegendPosition): string;
-    static getLegendItemsDirection(chartNotation: ChartNotation, legendPosition: LegendPosition): LegendItemsDirection;
-    static getSumOfItemsWidths(itemsWidth: number[], marginsLeft: number[]): number;
-    static getLegendCoordinateByPosition(legendPosition: Orient, legendBlockModel: LegendBlockModel, blockSize: Size): LegendCoordinate;
-}

package/lib/engine/features/legend/legendHelper.js

@@ -1,97 +0,0 @@
-import { Helper } from '../../helpers/helper';
-import { Legend } from "./legend";
-export class LegendHelper {
-    static getLegendItemsContent(options, data) {
-        if (options.type === '2d') {
-            let texts = [];
-            options.charts.forEach(chart => {
-                texts = texts.concat(chart.data.valueFields.map(field => field.title));
-            });
-            return texts;
-        }
-        else if (options.type === 'polar') {
-            return data[options.data.dataSource].map((record) => record[options.data.keyField.name]);
-        }
-        else if (options.type === 'interval') {
-            return options.charts.map(chart => chart.data.valueField1.name);
-        }
-    }
-    static getMarksColor(options) {
-        if (options.type === '2d') {
-            let colors = [];
-            options.charts.forEach(chart => {
-                colors = colors.concat(chart.style.elementColors);
-            });
-            return colors;
-        }
-        else if (options.type === 'polar') {
-            return options.charts.map(chart => chart.style.elementColors)[0];
-        }
-        else if (options.type === 'interval') {
-            return options.charts.map(chart => chart.style.elementColors[0]);
-        }
-    }
-    static getMaxItemWidth(legendBlockWidth, marginsLeft, itemsDirection) {
-        if (itemsDirection === 'row') {
-            const sumOfMargins = Helper.getSumOfNumeric(marginsLeft);
-            return (parseFloat(legendBlockWidth) - sumOfMargins) / marginsLeft.length;
-        }
-        return parseFloat(legendBlockWidth);
-    }
-    static getItemClasses(itemsDirection, position, index) {
-        let cssClasses = this.getLegendItemClassByDirection(itemsDirection);
-        if (itemsDirection === 'column' && index !== 0)
-            cssClasses += ` ${this.getLegendItemsMarginClass(position)}`;
-        return cssClasses;
-    }
-    static getLegendItemClassByDirection(itemsDirection) {
-        return itemsDirection === 'column' ? 'legend-item-row' : 'legend-item-inline';
-    }
-    static getLegendItemsMarginClass(legendPosition) {
-        return legendPosition === 'right' ? 'mt-15' : 'mt-10';
-    }
-    static getLegendLabelClassByPosition(position) {
-        if (position === 'top' || position === 'bottom')
-            return `${Legend.labelClass} ${Legend.labelClass + '-nowrap'}`;
-        return Legend.labelClass;
-    }
-    static getLegendItemsDirection(chartNotation, legendPosition) {
-        if (legendPosition === 'right' || legendPosition === 'left')
-            return 'column';
-        else
-            return chartNotation === 'polar' ? 'column' : 'row';
-    }
-    static getSumOfItemsWidths(itemsWidth, marginsLeft) {
-        let sumOfItemsWidth = Helper.getSumOfNumeric(itemsWidth);
-        sumOfItemsWidth += Helper.getSumOfNumeric(marginsLeft);
-        return sumOfItemsWidth;
-    }
-    static getLegendCoordinateByPosition(legendPosition, legendBlockModel, blockSize) {
-        const legendModel = legendBlockModel.coordinate[legendPosition];
-        const coordinate = {
-            x: 0,
-            y: 0,
-            width: 0,
-            height: 0
-        };
-        if (legendPosition === 'left' || legendPosition === 'right') {
-            coordinate.y = legendModel.margin.top + legendModel.pad;
-            coordinate.width = legendModel.size;
-            coordinate.height = blockSize.height - legendModel.margin.top - legendModel.margin.bottom;
-        }
-        else if (legendPosition === 'bottom' || legendPosition === 'top') {
-            coordinate.x = legendModel.margin.left;
-            coordinate.width = blockSize.width - legendModel.margin.left - legendModel.margin.right;
-            coordinate.height = legendModel.size;
-        }
-        if (legendPosition === 'left')
-            coordinate.x = legendModel.margin.left;
-        else if (legendPosition === 'right')
-            coordinate.x = blockSize.width - legendModel.size - legendModel.margin.right;
-        else if (legendPosition === 'top')
-            coordinate.y = legendModel.margin.top + legendModel.pad;
-        else if (legendPosition === 'bottom')
-            coordinate.y = blockSize.height - legendModel.size - legendModel.margin.bottom;
-        return coordinate;
-    }
-}

package/lib/engine/features/markDots/markDot.d.ts

@@ -1,20 +0,0 @@
-import { Selection, BaseType } from 'd3-selection';
-import { MdtChartsDataRow } from '../../../config/config';
-import { BlockMargin, Orient, TwoDimensionalChartModel } from "../../../model/model";
-import { Block } from "../../block/block";
-import { Scales } from "../scale/scale";
-export interface DotAttrs {
-    cx: (data: MdtChartsDataRow) => number;
-    cy: (data: MdtChartsDataRow) => number;
-}
-export declare class MarkDot {
-    static readonly markerDotClass: string;
-    static readonly hiddenDotClass: string;
-    private static dotRadius;
-    static render(block: Block, data: MdtChartsDataRow[], keyAxisOrient: Orient, scales: Scales, margin: BlockMargin, keyFieldName: string, vfIndex: number, valueFieldName: string, chart: TwoDimensionalChartModel): void;
-    static update(block: Block, newData: MdtChartsDataRow[], keyAxisOrient: Orient, scales: Scales, margin: BlockMargin, keyField: string, vfIndex: number, valueFieldName: string, chart: TwoDimensionalChartModel): void;
-    static updateColors(block: Block, chart: TwoDimensionalChartModel, valueFieldIndex: number): void;
-    static getMarkDotForChart(block: Block, chartCssClasses: string[]): Selection<BaseType, MdtChartsDataRow, BaseType, unknown>;
-    private static setClassesAndStyle;
-    private static setAttrs;
-}

package/lib/engine/features/markDots/markDot.js

@@ -1,68 +0,0 @@
-import { select } from 'd3-selection';
-import { transition } from 'd3-transition';
-import { DomHelper } from '../../helpers/domHelper';
-import { Helper } from '../../helpers/helper';
-import { NamesHelper } from '../../helpers/namesHelper';
-import { MarkDotHelper } from "./markDotsHelper";
-select.prototype.transition = transition;
-export class MarkDot {
-    static render(block, data, keyAxisOrient, scales, margin, keyFieldName, vfIndex, valueFieldName, chart) {
-        const dotsWrapper = block.getChartGroup(chart.index)
-            .selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-index-${vfIndex}`)
-            .data(data)
-            .enter();
-        const attrs = MarkDotHelper.getDotAttrs(keyAxisOrient, scales, margin, keyFieldName, valueFieldName, chart.isSegmented);
-        const dots = dotsWrapper.append('circle');
-        this.setAttrs(block, dots, attrs);
-        this.setClassesAndStyle(dots, chart.cssClasses, vfIndex, chart.style.elementColors);
-        if (!chart.markersOptions.show)
-            dots.classed(this.hiddenDotClass, true);
-    }
-    static update(block, newData, keyAxisOrient, scales, margin, keyField, vfIndex, valueFieldName, chart) {
-        const dots = block.getChartGroup(chart.index)
-            .selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${vfIndex}`)
-            .data(newData);
-        dots.exit().remove();
-        const attrs = MarkDotHelper.getDotAttrs(keyAxisOrient, scales, margin, keyField, valueFieldName, chart.isSegmented);
-        const newDots = dots
-            .enter()
-            .append('circle');
-        this.setAttrs(block, newDots, attrs);
-        this.setClassesAndStyle(newDots, chart.cssClasses, vfIndex, chart.style.elementColors);
-        if (!chart.markersOptions.show)
-            newDots.classed(this.hiddenDotClass, true);
-        const animationName = 'data-updating';
-        dots
-            .interrupt(animationName)
-            .transition(animationName)
-            .duration(block.transitionManager.durations.chartUpdate)
-            .attr('cx', d => attrs.cx(d))
-            .attr('cy', d => attrs.cy(d));
-    }
-    static updateColors(block, chart, valueFieldIndex) {
-        const dots = block.getChartGroup(chart.index)
-            .selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${valueFieldIndex}`);
-        DomHelper.setChartElementColor(dots, chart.style.elementColors, valueFieldIndex, 'stroke');
-    }
-    static getMarkDotForChart(block, chartCssClasses) {
-        return block.getSvg()
-            .selectAll(`.${MarkDot.markerDotClass}${Helper.getCssClassesLine(chartCssClasses)}`);
-    }
-    static setClassesAndStyle(dots, cssClasses, vfIndex, elementColors) {
-        DomHelper.setCssClasses(dots, Helper.getCssClassesWithElementIndex(cssClasses, vfIndex));
-        DomHelper.setChartElementColor(dots, elementColors, vfIndex, 'stroke');
-    }
-    static setAttrs(block, dots, attrs) {
-        dots
-            .attr('class', this.markerDotClass)
-            .attr('cx', d => attrs.cx(d))
-            .attr('cy', d => attrs.cy(d))
-            .attr('r', this.dotRadius)
-            .style('stroke-width', '3px')
-            .style('fill', 'white')
-            .style('clip-path', `url(#${block.getClipPathId()})`);
-    }
-}
-MarkDot.markerDotClass = NamesHelper.getClassName('dot');
-MarkDot.hiddenDotClass = NamesHelper.getClassName('dot-hidden');
-MarkDot.dotRadius = 4;

package/lib/engine/features/markDots/markDotsHelper.d.ts

@@ -1,6 +0,0 @@
-import { BlockMargin, Orient } from "../../../model/model";
-import { Scales } from "../scale/scale";
-import { DotAttrs } from "./markDot";
-export declare class MarkDotHelper {
-    static getDotAttrs(keyAxisOrient: Orient, scales: Scales, margin: BlockMargin, keyField: string, valueField: string, isSegmented: boolean): DotAttrs;
-}

package/lib/engine/features/markDots/markDotsHelper.js

@@ -1,16 +0,0 @@
-import { Helper } from "../../helpers/helper";
-import { Scale } from "../scale/scale";
-export class MarkDotHelper {
-    static getDotAttrs(keyAxisOrient, scales, margin, keyField, valueField, isSegmented) {
-        const attrs = { cx: null, cy: null };
-        if (keyAxisOrient === 'left' || keyAxisOrient === 'right') {
-            attrs.cx = d => scales.value(d[valueField]) + margin.left;
-            attrs.cy = d => Scale.getScaledValue(scales.key, Helper.getKeyFieldValue(d, keyField, isSegmented)) + margin.top;
-        }
-        else if (keyAxisOrient === 'bottom' || keyAxisOrient === 'top') {
-            attrs.cx = d => Scale.getScaledValue(scales.key, Helper.getKeyFieldValue(d, keyField, isSegmented)) + margin.left;
-            attrs.cy = d => scales.value(d[valueField]) + margin.top;
-        }
-        return attrs;
-    }
-}

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

@@ -1,14 +0,0 @@
-import { ChartOrientation } from "../../../config/config";
-import { Block } from "../../block/block";
-declare type AlertBlockPosition = 'top' | 'bottom' | 'right' | 'left';
-export declare class RecordOverflowAlert {
-    private static readonly blockClass;
-    static render(block: Block, hidedRecordsAmount: number, position: AlertBlockPosition, chartOrientation?: ChartOrientation): void;
-    static update(block: Block, hidedRecordsAmount: number, position: AlertBlockPosition, chartOrientation?: ChartOrientation): void;
-    private static setAlertPosition;
-    private static getAlertText;
-    private static getWordTextEndingByAmount;
-    private static getBlockPositionAttrs;
-    private static getLeftAttrForRightBlock;
-}
-export {};