mdt-charts 1.28.2 → 1.29.0

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

@@ -4,20 +4,55 @@ import { BlockMargin, EmbeddedLabelTypeModel, Field, Orient } from "../../../mod
 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;
+	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

@@ -5,140 +5,240 @@ 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.svg
-                .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.svg
-            .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.svg
-            .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.svg.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.svg
-            .getChartBlock()
-            .select(`.${this.embeddedLabelsGroupClass}${Helper.getCssClassesLine(cssClasses)}`)
-            .raise();
-        if (group.empty())
-            group = block.svg.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;
-    }
+	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.svg
+				.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.svg
+			.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.svg
+			.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.svg.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.svg
+			.getChartBlock()
+			.select(`.${this.embeddedLabelsGroupClass}${Helper.getCssClassesLine(cssClasses)}`)
+			.raise();
+		if (group.empty())
+			group = block.svg.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";

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

@@ -3,6 +3,17 @@ 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;
+	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,27 +1,24 @@
 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);
-    }
+	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

@@ -3,25 +3,42 @@ 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;
+	x: number;
+	y: number;
+	textAnchor: TextAnchor;
 }
 export interface BarAttrs {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
+	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;
+	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;
 }