mdt-charts 1.9.7 → 1.9.11

package/lib/engine/features/axis/axisDomHelper.js

@@ -1,24 +0,0 @@
-export class AxisDomHelper {
-    static updateAxisElement(axisGenerator, axisElement, translate, transitionDuration = 0) {
-        return new Promise(resolve => {
-            let axisHandler = axisElement;
-            if (transitionDuration > 0) {
-                axisHandler = axisHandler
-                    .interrupt()
-                    .transition()
-                    .duration(transitionDuration)
-                    .on('end', () => resolve('updated'));
-            }
-            axisHandler.attr('transform', `translate(${translate.translateX}, ${translate.translateY})`)
-                .call(axisGenerator.bind(this));
-            if (transitionDuration <= 0)
-                resolve('updated');
-        });
-    }
-    static rotateElementsBack(axisElement) {
-        axisElement.selectAll('.tick text')
-            .attr('transform', null)
-            .attr('text-anchor', 'middle')
-            .attr('x', null);
-    }
-}

package/lib/engine/features/axis/axisHelper.d.ts

@@ -1,9 +0,0 @@
-import { AxisScale, Axis as IAxis } from 'd3-axis';
-import { AxisModelOptions, Orient, ScaleKeyModel, ScaleValueModel } from "../../../model/model";
-export declare class AxisHelper {
-    static getAxisByOrient(orient: Orient, scale: AxisScale<any>): IAxis<any>;
-    static setLabelsSettings(axisGenerator: IAxis<any>, range: number[], scaleOptions: ScaleValueModel): void;
-    static getBaseAxisGenerator(axisOptions: AxisModelOptions, scale: AxisScale<any>, scaleOptions: ScaleKeyModel | ScaleValueModel): IAxis<any>;
-    private static removeTicks;
-    private static setNumTickFormat;
-}

package/lib/engine/features/axis/axisHelper.js

@@ -1,53 +0,0 @@
-import { axisTop, axisBottom, axisLeft, axisRight } from 'd3-axis';
-import { max, min } from 'd3-array';
-import { format } from 'd3-format';
-import { AxisLabelHelper } from './axisLabelDomHelper';
-const MINIMAL_STEP_SIZE = 40;
-export class AxisHelper {
-    static getAxisByOrient(orient, scale) {
-        if (orient === 'top')
-            return axisTop(scale);
-        if (orient === 'bottom')
-            return axisBottom(scale);
-        if (orient === 'left')
-            return axisLeft(scale);
-        if (orient === 'right')
-            return axisRight(scale);
-    }
-    static setLabelsSettings(axisGenerator, range, scaleOptions) {
-        const axisLength = range[1] - range[0];
-        let ticksAmount;
-        if (axisLength / 10 < MINIMAL_STEP_SIZE) {
-            if (Math.floor(axisLength / MINIMAL_STEP_SIZE) > 2) {
-                ticksAmount = Math.floor(axisLength / MINIMAL_STEP_SIZE);
-                axisGenerator.ticks(Math.floor(axisLength / MINIMAL_STEP_SIZE));
-            }
-            else {
-                ticksAmount = 2;
-                axisGenerator.tickValues([min(scaleOptions.domain), max(scaleOptions.domain)]);
-            }
-        }
-        if (scaleOptions.type === 'linear') {
-            axisGenerator.scale().ticks(ticksAmount).forEach((value) => {
-                if (format('~s')(value).indexOf('.') !== -1) {
-                    this.setNumTickFormat(axisGenerator, '.2s');
-                }
-            });
-        }
-    }
-    static getBaseAxisGenerator(axisOptions, scale, scaleOptions) {
-        const axisGenerator = AxisHelper.getAxisByOrient(axisOptions.orient, scale);
-        if (!axisOptions.ticks.flag)
-            this.removeTicks(axisGenerator);
-        AxisLabelHelper.setAxisLabelPaddingByOrient(axisGenerator, axisOptions);
-        if (scaleOptions.type === 'linear')
-            this.setNumTickFormat(axisGenerator);
-        return axisGenerator;
-    }
-    static removeTicks(axis) {
-        axis.tickSize(0);
-    }
-    static setNumTickFormat(axis, formatName = '~s') {
-        axis.tickFormat(format(formatName));
-    }
-}

package/lib/engine/features/axis/axisLabelDomHelper.d.ts

@@ -1,17 +0,0 @@
-import { Selection, BaseType } from 'd3-selection';
-import { AxisScale, Axis as IAxis } from 'd3-axis';
-import { AxisModelOptions, Orient, ScaleKeyModel, ScaleValueModel } from "../../../model/model";
-import { Block } from "../../block/block";
-import { Size } from '../../../config/config';
-export declare class AxisLabelHelper {
-    static setTitles(axisElement: Selection<SVGGElement, unknown, BaseType, any>): void;
-    static setAxisLabelPaddingByOrient(axis: IAxis<any>, axisOptions: AxisModelOptions): void;
-    static rotateLabels(axisElement: Selection<SVGGElement, unknown, HTMLElement, any>, keyAxisOrient: Orient): void;
-    static cropLabels(block: Block, scale: AxisScale<any>, scaleOptions: ScaleKeyModel | ScaleValueModel, axisOptions: AxisModelOptions, blockSize: Size): void;
-    static hideLabels(axisElement: Selection<SVGGElement, unknown, BaseType, unknown>): void;
-    static alignLabelsInKeyAxis(axisOptions: AxisModelOptions, axisElement: Selection<SVGGElement, unknown, HTMLElement, any>): void;
-    private static alignLabelsInVerticalAxis;
-    private static cropAndAlignExtremeLabels;
-    private static getTranslateNumber;
-    static wrapHandler(textBlocks: Selection<SVGGElement, unknown, BaseType, any>, maxWidth: number): void;
-}

package/lib/engine/features/axis/axisLabelDomHelper.js

@@ -1,143 +0,0 @@
-import { select } from 'd3-selection';
-import { AXIS_HORIZONTAL_LABEL_PADDING, AXIS_VERTICAL_LABEL_PADDING } from "../../../model/marginModel";
-import { DomHelper } from '../../helpers/domHelper';
-import { Helper } from '../../helpers/helper';
-export class AxisLabelHelper {
-    static setTitles(axisElement) {
-        axisElement.selectAll('.tick text')
-            .each(function (d, i) {
-            const tickTitle = select(this).select('title');
-            if (tickTitle.empty())
-                select(this)
-                    .append('title')
-                    .text(d);
-            else
-                tickTitle.text(d);
-        });
-    }
-    static setAxisLabelPaddingByOrient(axis, axisOptions) {
-        let axisLabelPadding = AXIS_HORIZONTAL_LABEL_PADDING;
-        if (axisOptions.orient === 'left' || axisOptions.orient === 'right')
-            axisLabelPadding = AXIS_VERTICAL_LABEL_PADDING;
-        axis.tickPadding(axisLabelPadding);
-    }
-    static rotateLabels(axisElement, keyAxisOrient) {
-        const labelBlocks = axisElement.selectAll('text');
-        labelBlocks.attr('transform', 'rotate(-90)');
-        if (keyAxisOrient === 'bottom') {
-            labelBlocks
-                .attr('text-anchor', 'end')
-                .attr('x', -AXIS_HORIZONTAL_LABEL_PADDING)
-                .attr('y', -4);
-        }
-        else if (keyAxisOrient === 'top') {
-            labelBlocks
-                .attr('text-anchor', 'start')
-                .attr('x', AXIS_HORIZONTAL_LABEL_PADDING)
-                .attr('y', 6);
-        }
-    }
-    static cropLabels(block, scale, scaleOptions, axisOptions, blockSize) {
-        if (scaleOptions.type === 'point' || scaleOptions.type === 'band') {
-            const axisTextBlocks = block.getSvg().select(`.${axisOptions.cssClass}`).selectAll('text');
-            let maxLabelSize;
-            if ((axisOptions.orient === 'left' || axisOptions.orient === 'right') || (axisOptions.type === 'key' && axisOptions.labels.position === 'rotated'))
-                maxLabelSize = axisOptions.labels.maxSize;
-            else
-                maxLabelSize = scale.step() - 4;
-            DomHelper.cropSvgLabels(axisTextBlocks, maxLabelSize);
-            if (scaleOptions.type === 'point' && axisOptions.labels.position === 'straight' && (axisOptions.orient === 'top' || axisOptions.orient === 'bottom')) {
-                this.cropAndAlignExtremeLabels(block, maxLabelSize, axisOptions, blockSize);
-            }
-        }
-    }
-    static hideLabels(axisElement) {
-        axisElement.selectAll('.tick text').style('display', 'none');
-    }
-    static alignLabelsInKeyAxis(axisOptions, axisElement) {
-        if (axisOptions.orient === 'left')
-            this.alignLabelsInVerticalAxis(axisElement, 'start', axisOptions.labels.maxSize, true);
-        else if (axisOptions.orient === 'right')
-            this.alignLabelsInVerticalAxis(axisElement, 'start', axisOptions.labels.maxSize, false);
-    }
-    static alignLabelsInVerticalAxis(axisElement, anchor, maxLabelSize, changeCoordinate) {
-        const axisTextBlocks = axisElement.selectAll('text');
-        const spans = axisElement.selectAll('tspan');
-        axisTextBlocks.attr('text-anchor', anchor);
-        spans.attr('text-anchor', anchor);
-        if (changeCoordinate) {
-            axisTextBlocks.attr('x', -(maxLabelSize + AXIS_VERTICAL_LABEL_PADDING));
-            spans.attr('x', -(maxLabelSize + AXIS_VERTICAL_LABEL_PADDING));
-        }
-        else {
-            spans.attr('x', AXIS_VERTICAL_LABEL_PADDING);
-        }
-    }
-    static cropAndAlignExtremeLabels(block, maxLabelSize, axisOptions, blockSize) {
-        const lastTick = block.getSvg().select(`.${axisOptions.cssClass}`).select('.tick:last-of-type');
-        const lastLabel = lastTick.select('text');
-        if (lastTick.size() === 0 || lastLabel.size() === 0)
-            return;
-        const tickTranslateX = Helper.getTranslateNumbers(lastTick.attr('transform'))[0];
-        const marginRight = blockSize.width - axisOptions.translate.translateX - tickTranslateX;
-        if (tickTranslateX + lastLabel.node().getBBox().width + axisOptions.translate.translateX > blockSize.width) {
-            lastLabel.attr('text-anchor', 'start');
-            lastLabel.attr('transform', `translate(${this.getTranslateNumber(maxLabelSize, lastLabel, marginRight)}, 0)`);
-            DomHelper.cropSvgLabels(lastLabel, maxLabelSize / 2 + marginRight);
-        }
-        const firstLabel = block.getSvg()
-            .select(`.${axisOptions.cssClass}`)
-            .select('.tick:first-of-type')
-            .select('text');
-        const axisElementTranslate = Helper.getTranslateNumbers(block.getSvg().select(`.${axisOptions.cssClass}`).attr('transform'))[0];
-        if (axisOptions.translate.translateX - firstLabel.node().getBBox().width / 2 < 0) {
-            firstLabel.attr('text-anchor', 'start');
-            firstLabel.attr('transform', `translate(${-axisOptions.translate.translateX}, 0)`);
-            DomHelper.cropSvgLabels(firstLabel, maxLabelSize / 2 + axisElementTranslate);
-        }
-    }
-    static getTranslateNumber(maxLabelSize, lastLabel, marginRight) {
-        if (maxLabelSize / 2 > lastLabel.node().getBBox().width)
-            return -(lastLabel.node().getBBox().width - marginRight);
-        return -maxLabelSize / 2;
-        // return -Math.min(maxLabelSize / 2, lastLabel.node().getBBox().width - marginRight)
-    }
-    static wrapHandler(textBlocks, maxWidth) {
-        textBlocks.each(function () {
-            let textBlock = select(this);
-            if (!textBlock.selectAll('tspan').empty())
-                return;
-            textBlock.select('title').remove();
-            let textContent = textBlock.text();
-            if (textBlock.node().getBBox().width > maxWidth) {
-                let letters = textBlock.text().split('').reverse(), // split text to letters.
-                letter, line = [], // one line. letters from this var into tpsans.
-                lineNumber = 0, dy = 1.4, tspan = textBlock.text(null).append("tspan").attr("dy", dy + "em");
-                while (letter = letters.pop()) {
-                    line.push(letter);
-                    tspan.text(line.join(''));
-                    if (tspan.node().getComputedTextLength() > maxWidth && line.length > 1 && letters.length > 0) {
-                        line.pop();
-                        tspan.text(line.join(''));
-                        if (lineNumber === 0 && line[line.length - 1] !== ' ')
-                            tspan.text(tspan.text() + '-');
-                        line = [letter];
-                        if (lineNumber >= 1) { // If text block has 2 lines, text cropped.
-                            if (letters.length > 0)
-                                tspan.text(tspan.text().substr(0, tspan.text().length - 1) + '...');
-                            break;
-                        }
-                        tspan = textBlock.append("tspan").attr("dy", dy * lineNumber + 1 + "em").text(letter);
-                        lineNumber++;
-                    }
-                }
-                if (textBlock.selectAll('tspan').size() === 1) {
-                    textBlock.text(textContent).attr('y', null);
-                }
-                if (!textBlock.selectAll('tspan').empty()) {
-                    textBlock.attr('y', -(textBlock.node().getBBox().height / 2 + 4.8));
-                }
-            }
-        });
-    }
-}

package/lib/engine/features/axis/axisLabelsEventManager.d.ts

@@ -1,6 +0,0 @@
-import { Selection } from "d3-selection";
-import { Block } from "../../block/block";
-export declare class AxisLabelsEventManager {
-    static setHoverEvents(block: Block, axisElement: Selection<SVGGElement, unknown, HTMLElement, any>): void;
-    static removeEvents(axisElement: Selection<SVGGElement, unknown, HTMLElement, any>): void;
-}

package/lib/engine/features/axis/axisLabelsEventManager.js

@@ -1,36 +0,0 @@
-import { pointer } from "d3-selection";
-import { TipBox } from "../tipBox/tipBox";
-export class AxisLabelsEventManager {
-    static setHoverEvents(block, axisElement) {
-        const labels = axisElement.selectAll('.tick text');
-        labels.on('mousemove', function (e, d) {
-            TipBox.get(block).dispatch('mousemove', {
-                bubbles: false,
-                cancelable: true,
-                detail: {
-                    keyValue: d,
-                    pointer: pointer(e, block.getWrapper().node())
-                }
-            });
-        });
-        labels.on('mouseleave', function (e, d) {
-            TipBox.get(block).dispatch('mouseleave');
-        });
-        labels.on('click', function (e, d) {
-            TipBox.get(block).dispatch('click', {
-                bubbles: false,
-                cancelable: true,
-                detail: {
-                    multySelect: e.ctrlKey || e.metaKey,
-                    keyValue: d
-                }
-            });
-        });
-    }
-    static removeEvents(axisElement) {
-        const labels = axisElement.selectAll('.tick text');
-        labels.on('mousemove', null);
-        labels.on('mouseleave', null);
-        labels.on('click', null);
-    }
-}

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

@@ -1,23 +0,0 @@
-import { Selection } from 'd3-selection';
-import { MdtChartsDataRow, Size } from '../../../config/config';
-import { BlockMargin, EmbeddedLabelTypeModel, Field, Orient } from "../../../model/model";
-import { Block } from "../../block/block";
-import { BarAttrsHelper } from '../../twoDimensionalNotation/bar/barHelper';
-export declare class EmbeddedLabels {
-    static embeddedLabelsGroupClass: string;
-    static embeddedLabelClass: string;
-    private static embeddedLabelBgClass;
-    private static innerLabelColor;
-    private static outerLabelColor;
-    static render(block: Block, bars: Selection<SVGRectElement, MdtChartsDataRow, SVGGElement, any>, barAttrsHelper: BarAttrsHelper, field: Field, type: EmbeddedLabelTypeModel, keyAxisOrient: Orient, blockSize: Size, margin: BlockMargin, index: number, cssClasses: string[]): void;
-    static restoreRemoved(block: Block, bars: Selection<SVGRectElement, MdtChartsDataRow, SVGGElement, any>, barAttrsHelper: BarAttrsHelper, field: Field, type: EmbeddedLabelTypeModel, keyAxisOrient: Orient, blockSize: Size, margin: BlockMargin, index: number, cssClasses: string[], keyFieldName: string): void;
-    static removeUnused(block: Block, chartCssClasses: string[], fieldIndex: number, indexes: number[]): void;
-    static update(block: Block, bars: Selection<SVGRectElement, MdtChartsDataRow, SVGGElement, unknown>, keyAxisOrient: Orient, barAttrsHelper: BarAttrsHelper, margin: BlockMargin, valueField: Field, type: EmbeddedLabelTypeModel, blockSize: Size, newData: MdtChartsDataRow[], index: number, cssClasses: string[]): void;
-    static raiseGroups(block: Block): void;
-    private static renderLabel;
-    private static updateLabel;
-    private static checkLabelToResetTextAnchor;
-    private static renderGroup;
-    private static renderBackground;
-    private static getLabelByIndex;
-}

package/lib/engine/features/embeddedLabels/embeddedLabels.js

@@ -1,147 +0,0 @@
-import { select } from 'd3-selection';
-import { DomHelper } from '../../helpers/domHelper';
-import { Helper } from '../../helpers/helper';
-import { ValueFormatter } from "../../valueFormatter";
-import { EmbeddedLabelsDomHelper } from './embeddedLabelsDomHelper';
-import { EmbeddedLabelsHelper } from "./embeddedLabelsHelper";
-export class EmbeddedLabels {
-    static render(block, bars, barAttrsHelper, field, type, keyAxisOrient, blockSize, margin, index, cssClasses) {
-        const labelsGroup = this.renderGroup(block, Helper.getCssClassesWithElementIndex(cssClasses, index));
-        DomHelper.setCssClasses(labelsGroup, Helper.getCssClassesWithElementIndex(cssClasses, index));
-        bars.each(dataRow => {
-            this.renderLabel(labelsGroup, barAttrsHelper, dataRow, field, type, keyAxisOrient, blockSize, margin);
-        });
-    }
-    static restoreRemoved(block, bars, barAttrsHelper, field, type, keyAxisOrient, blockSize, margin, index, cssClasses, keyFieldName) {
-        const untaggedBars = bars.filter(d => {
-            return block.getChartBlock()
-                .selectAll(`.${EmbeddedLabels.embeddedLabelsGroupClass}${Helper.getCssClassesLine(cssClasses)}.chart-element-${index}`)
-                .selectAll(`.${this.embeddedLabelClass}`)
-                .filter(row => row[keyFieldName] === d[keyFieldName])
-                .empty();
-        });
-        if (!untaggedBars.empty()) {
-            this.render(block, untaggedBars, barAttrsHelper, field, type, keyAxisOrient, blockSize, margin, index, cssClasses);
-        }
-    }
-    static removeUnused(block, chartCssClasses, fieldIndex, indexes) {
-        block.getChartBlock()
-            .selectAll(`.${EmbeddedLabels.embeddedLabelsGroupClass}${Helper.getCssClassesLine(chartCssClasses)}.chart-element-${fieldIndex}`)
-            .selectAll(`.${this.embeddedLabelClass}`)
-            .filter((d, i) => indexes.findIndex(ind => ind === i) !== -1)
-            .remove();
-    }
-    static update(block, bars, keyAxisOrient, barAttrsHelper, margin, valueField, type, blockSize, newData, index, cssClasses) {
-        const labelsGroup = block.getChartBlock()
-            .selectAll(`.${EmbeddedLabels.embeddedLabelsGroupClass}${Helper.getCssClassesLine(cssClasses)}.chart-element-${index}`);
-        labelsGroup.selectAll(`.${this.embeddedLabelBgClass}`)
-            .remove();
-        const labelsSelection = labelsGroup
-            .selectAll(`.${this.embeddedLabelClass}`)
-            .data(newData);
-        bars.each((dataRow, barIndex) => {
-            const labelBlock = this.getLabelByIndex(labelsSelection, barIndex, valueField, dataRow);
-            if (labelBlock)
-                this.updateLabel(block, dataRow, keyAxisOrient, barAttrsHelper, margin, type, blockSize, labelBlock, labelsGroup);
-        });
-    }
-    static raiseGroups(block) {
-        block.getChartBlock().selectAll(`.${this.embeddedLabelsGroupClass}`).raise();
-    }
-    static renderLabel(labelsGroup, barAttrsHelper, dataRow, field, type, keyAxisOrient, blockSize, margin) {
-        const labelBlock = labelsGroup.append('text').datum(dataRow);
-        labelBlock
-            .classed(EmbeddedLabels.embeddedLabelClass, true)
-            .style('pointer-events', 'none')
-            .text(ValueFormatter.formatField(field.format, dataRow[field.name]));
-        const barAttrs = {
-            x: barAttrsHelper.x(dataRow),
-            width: barAttrsHelper.width(dataRow),
-            y: barAttrsHelper.y(dataRow),
-            height: barAttrsHelper.height(dataRow)
-        };
-        const labelUnserveFlag = EmbeddedLabelsHelper.getLabelUnserveFlag(barAttrs.height); // if bar is too small to serve label inside. This flag is needed for set outside postion and change text anchor if bar wide as whole chart block
-        const position = EmbeddedLabelsHelper.getLabelPosition(barAttrs, labelBlock.node().getBBox().width, margin, blockSize, labelUnserveFlag);
-        const attrs = EmbeddedLabelsHelper.getLabelAttrs(barAttrs, type, position, keyAxisOrient, labelBlock.node().getBBox().width);
-        if (position === 'outside') {
-            attrs.x = this.checkLabelToResetTextAnchor(attrs.x, labelBlock.node().getBBox().width, margin, blockSize, keyAxisOrient);
-            this.renderBackground(labelsGroup, labelBlock, attrs);
-        }
-        EmbeddedLabelsDomHelper.setLabelBlockAttrs(attrs, labelBlock);
-        if (position === 'inside')
-            labelBlock.style('fill', this.innerLabelColor);
-        EmbeddedLabelsDomHelper.cropText(labelBlock, barAttrs, position, labelUnserveFlag, margin, blockSize);
-    }
-    static updateLabel(block, dataRow, keyAxisOrient, barAttrsHelper, margin, type, blockSize, labelBlock, labelsGroup) {
-        const barAttrs = {
-            x: barAttrsHelper.x(dataRow),
-            width: barAttrsHelper.width(dataRow),
-            y: barAttrsHelper.y(dataRow),
-            height: barAttrsHelper.height(dataRow)
-        };
-        const labelUnserveFlag = EmbeddedLabelsHelper.getLabelUnserveFlag(barAttrs.height); // if bar is too small to serve label inside. This flag is needed for set outside postion and change text anchor if bar wide as whole chart block
-        const position = EmbeddedLabelsHelper.getLabelPosition(barAttrs, labelBlock.node().getBBox().width, margin, blockSize, labelUnserveFlag);
-        const attrs = EmbeddedLabelsHelper.getLabelAttrs(barAttrs, type, position, keyAxisOrient, labelBlock.node().getBBox().width);
-        EmbeddedLabelsDomHelper.cropText(labelBlock, barAttrs, position, labelUnserveFlag, margin, blockSize);
-        if (position === 'outside') {
-            attrs.x = this.checkLabelToResetTextAnchor(attrs.x, labelBlock.node().getBBox().width, margin, blockSize, keyAxisOrient);
-            labelBlock.style('fill', this.outerLabelColor);
-        }
-        EmbeddedLabelsDomHelper.setLabelBlockAttrs(attrs, labelBlock, block.transitionManager.durations.chartUpdate)
-            .then(() => {
-            if (position === 'outside')
-                this.renderBackground(labelsGroup, labelBlock, attrs);
-            if (position === 'inside')
-                labelBlock.style('fill', this.innerLabelColor);
-        });
-    }
-    static checkLabelToResetTextAnchor(x, width, margin, blockSize, keyAxisOrient) {
-        if (keyAxisOrient === 'left') {
-            if (x + width > blockSize.width - margin.right)
-                return blockSize.width - margin.right - width;
-            return x;
-        }
-        if (keyAxisOrient === 'right') {
-            if (x < margin.left)
-                return margin.left;
-            return x;
-        }
-    }
-    static renderGroup(block, cssClasses) {
-        let group = block.getChartBlock()
-            .select(`.${this.embeddedLabelsGroupClass}${Helper.getCssClassesLine(cssClasses)}`)
-            .raise();
-        if (group.empty())
-            group = block.getChartBlock()
-                .append('g')
-                .attr('class', this.embeddedLabelsGroupClass)
-                .raise();
-        return group;
-    }
-    static renderBackground(labelsGroup, labelBlock, attrs) {
-        labelsGroup.append('rect')
-            .attr('class', this.embeddedLabelBgClass)
-            .attr('x', attrs.x)
-            .attr('y', attrs.y - labelBlock.node().getBBox().height / 2)
-            .attr('width', labelBlock.node().getBBox().width)
-            .attr('height', labelBlock.node().getBBox().height)
-            .style('fill', 'rgba(255, 255, 255, 0.8)')
-            .lower();
-    }
-    static getLabelByIndex(labelsSelection, barIndex, valueField, dataRow) {
-        let labelBlock;
-        labelsSelection.each(function (d, indexLabel) {
-            if (barIndex === indexLabel) {
-                labelBlock = select(this)
-                    .datum(dataRow)
-                    .text(ValueFormatter.formatField(valueField.format, d[valueField.name]));
-            }
-        });
-        return labelBlock;
-    }
-}
-EmbeddedLabels.embeddedLabelsGroupClass = 'embedded-labels-group';
-EmbeddedLabels.embeddedLabelClass = 'embedded-label';
-EmbeddedLabels.embeddedLabelBgClass = 'embedded-label-bg';
-EmbeddedLabels.innerLabelColor = '#FFFFFF';
-EmbeddedLabels.outerLabelColor = '#000000';

package/lib/engine/features/embeddedLabels/embeddedLabelsDomHelper.d.ts

@@ -1,8 +0,0 @@
-import { BarAttrs, EmbeddedLabelPosition, LabelAttrs } from "./embeddedLabelsHelper";
-import { BaseType, Selection } from 'd3-selection';
-import { BlockMargin } from "../../../model/model";
-import { MdtChartsDataRow, Size } from "../../../config/config";
-export declare class EmbeddedLabelsDomHelper {
-    static setLabelBlockAttrs(attrs: LabelAttrs, labelBlock: Selection<SVGTextElement, MdtChartsDataRow, HTMLElement, unknown>, transitionDuration?: number): Promise<any>;
-    static cropText(labelBlock: Selection<SVGGraphicsElement, unknown, BaseType, unknown>, barAttrs: BarAttrs, position: EmbeddedLabelPosition, labelUnserveFlag: boolean, margin: BlockMargin, blockSize: Size): void;
-}

package/lib/engine/features/embeddedLabels/embeddedLabelsDomHelper.js

@@ -1,30 +0,0 @@
-import { EmbeddedLabelsHelper } from "./embeddedLabelsHelper";
-import { DomHelper } from "../../helpers/domHelper";
-export class EmbeddedLabelsDomHelper {
-    static setLabelBlockAttrs(attrs, labelBlock, transitionDuration = 0) {
-        return new Promise((resolve) => {
-            let labelBlockHandler = labelBlock;
-            if (transitionDuration > 0) {
-                labelBlockHandler = labelBlockHandler
-                    .interrupt()
-                    .transition()
-                    .duration(transitionDuration)
-                    .on('end', () => resolve('updated'));
-            }
-            labelBlockHandler
-                .attr('x', attrs.x)
-                .attr('y', attrs.y)
-                .attr('dominant-baseline', 'middle');
-            if (transitionDuration <= 0)
-                resolve('updated');
-        });
-    }
-    static cropText(labelBlock, barAttrs, position, labelUnserveFlag, margin, blockSize) {
-        let labelTextSpace;
-        if (labelUnserveFlag)
-            labelTextSpace = blockSize.width - margin.left - margin.right;
-        else
-            labelTextSpace = EmbeddedLabelsHelper.getSpaceSizeForType(position, barAttrs.width, margin, blockSize);
-        DomHelper.cropSvgLabels(labelBlock, labelTextSpace);
-    }
-}

package/lib/engine/features/embeddedLabels/embeddedLabelsHelper.d.ts

@@ -1,27 +0,0 @@
-import { BlockMargin, EmbeddedLabelTypeModel, Field, Orient } from "../../../model/model";
-import { Size } from "../../../config/config";
-export declare type EmbeddedLabelPosition = 'inside' | 'outside';
-export declare type TextAnchor = 'start' | 'end' | 'center';
-export interface LabelAttrs {
-    x: number;
-    y: number;
-    textAnchor: TextAnchor;
-}
-export interface BarAttrs {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-export declare const LABEL_BAR_PADDING = 6;
-export declare const MIN_BAR_HEIGHT_FOR_LABEL_SERVE = 12;
-export declare class EmbeddedLabelsHelper {
-    static getLabelPosition(barAttrs: BarAttrs, labelBlockWidth: number, margin: BlockMargin, blockSize: Size, labelUnserveFlag: boolean): EmbeddedLabelPosition;
-    static getSpaceSizeForType(position: EmbeddedLabelPosition, barWidth: number, margin: BlockMargin, blockSize: Size): number;
-    static getLabelAttrs(barAttrs: BarAttrs, type: EmbeddedLabelTypeModel, position: EmbeddedLabelPosition, keyAxisOrient: Orient, labelWidth: number): LabelAttrs;
-    static getLabelField(type: EmbeddedLabelTypeModel, valueFields: Field[], keyField: Field, index: number): Field;
-    static getLabelUnserveFlag(barHeight: number): boolean;
-    private static getLabelAttrX;
-    private static getLabelAttrY;
-    private static getTextAnchor;
-}

package/lib/engine/features/embeddedLabels/embeddedLabelsHelper.js

@@ -1,65 +0,0 @@
-export const LABEL_BAR_PADDING = 6;
-export const MIN_BAR_HEIGHT_FOR_LABEL_SERVE = 12;
-export class EmbeddedLabelsHelper {
-    static getLabelPosition(barAttrs, labelBlockWidth, margin, blockSize, labelUnserveFlag) {
-        if (labelUnserveFlag || this.getSpaceSizeForType('inside', barAttrs.width, margin, blockSize) < labelBlockWidth
-            && this.getSpaceSizeForType('inside', barAttrs.width, margin, blockSize) < this.getSpaceSizeForType('outside', barAttrs.width, margin, blockSize))
-            return 'outside';
-        return 'inside';
-    }
-    static getSpaceSizeForType(position, barWidth, margin, blockSize) {
-        if (position === 'outside')
-            return blockSize.width - margin.left - margin.right - barWidth - LABEL_BAR_PADDING;
-        return barWidth - LABEL_BAR_PADDING * 2;
-    }
-    static getLabelAttrs(barAttrs, type, position, keyAxisOrient, labelWidth) {
-        const textAnchor = this.getTextAnchor(type, position, keyAxisOrient);
-        const y = this.getLabelAttrY(barAttrs.y, barAttrs.height);
-        let x = this.getLabelAttrX(barAttrs, type, position, keyAxisOrient);
-        if (textAnchor === 'end') {
-            x = x - labelWidth;
-        }
-        return {
-            x,
-            y,
-            textAnchor
-        };
-    }
-    static getLabelField(type, valueFields, keyField, index) {
-        if (type === 'key')
-            return keyField;
-        if (type === 'value')
-            return valueFields[index];
-        return null;
-    }
-    static getLabelUnserveFlag(barHeight) {
-        return barHeight < MIN_BAR_HEIGHT_FOR_LABEL_SERVE;
-    }
-    static getLabelAttrX(barAttrs, type, position, keyAxisOrient) {
-        if (keyAxisOrient === 'left') {
-            if (position === 'outside')
-                return barAttrs.x + barAttrs.width + LABEL_BAR_PADDING;
-            if (type === 'key')
-                return barAttrs.x + LABEL_BAR_PADDING;
-            return barAttrs.x + barAttrs.width - LABEL_BAR_PADDING;
-        }
-        if (position === 'outside')
-            return barAttrs.x - LABEL_BAR_PADDING;
-        if (type === 'key')
-            return barAttrs.x + barAttrs.width - LABEL_BAR_PADDING;
-        return barAttrs.x + LABEL_BAR_PADDING;
-    }
-    static getLabelAttrY(barY, barHeight) {
-        return barY + barHeight / 2 + 1;
-    }
-    static getTextAnchor(type, position, keyAxisOrient) {
-        if (keyAxisOrient === 'left') {
-            if (position === 'outside' || type === 'key')
-                return 'start';
-            return 'end';
-        }
-        if (position === 'outside' || type === 'key')
-            return 'end';
-        return 'start';
-    }
-}

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

@@ -1,13 +0,0 @@
-import { Size } from "../../../config/config";
-import { AxisModelOptions, BlockMargin } from "../../../model/model";
-export declare type GridLineType = 'key' | 'value';
-export interface GridLineAttributes {
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-}
-export declare class GridLineHelper {
-    static getGridLineLength(gridLineType: GridLineType, keyAxis: AxisModelOptions, valueAxis: AxisModelOptions, blockSize: Size, margin: BlockMargin): number;
-    static getLineAttributes(axis: AxisModelOptions, lineLength: number): GridLineAttributes;
-}

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

@@ -1,30 +0,0 @@
-export class GridLineHelper {
-    static getGridLineLength(gridLineType, keyAxis, valueAxis, blockSize, margin) {
-        let axis;
-        let axisLength;
-        if (gridLineType === 'key')
-            axis = keyAxis;
-        else
-            axis = valueAxis;
-        if (axis.orient === 'left' || axis.orient === 'right')
-            axisLength = blockSize.width - margin.left - margin.right;
-        else
-            axisLength = blockSize.height - margin.top - margin.bottom;
-        if (axis.orient === 'right' || axis.orient === 'bottom')
-            axisLength = -axisLength;
-        return axisLength;
-    }
-    static getLineAttributes(axis, lineLength) {
-        const attributes = {
-            x1: 0,
-            y1: 0,
-            x2: 0,
-            y2: 0
-        };
-        if (axis.orient === 'left' || axis.orient === 'right')
-            attributes.x2 = lineLength;
-        else
-            attributes.y2 = lineLength;
-        return attributes;
-    }
-}