mdt-charts 1.29.0 → 1.30.0

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

@@ -1,60 +1,67 @@
 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";
-	}
+    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

@@ -3,19 +3,13 @@ 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;
+    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;
-	static getKeyLineAttributes(axis: AxisModelOptions, scaleValue: AxisScale<any>): GridLineAttributes;
+    static getGridLineLength(gridLineType: GridLineType, keyAxis: AxisModelOptions, valueAxis: AxisModelOptions, blockSize: Size, margin: BlockMargin): number;
+    static getLineAttributes(axis: AxisModelOptions, lineLength: number): GridLineAttributes;
+    static getKeyLineAttributes(axis: AxisModelOptions, scaleValue: AxisScale<any>): GridLineAttributes;
 }

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

@@ -1,45 +1,52 @@
 import { max, min } from "d3-array";
 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;
-	}
-	static getKeyLineAttributes(axis, scaleValue) {
-		const attributes = {
-			x1: 0,
-			y1: 0,
-			x2: 0,
-			y2: 0
-		};
-		const scaledStart = scaleValue(scaleValue.domain()[0]);
-		const scaledEnd = scaleValue(scaleValue.domain()[1]);
-		const minCoord = min([scaledStart, scaledEnd]) - scaleValue(0);
-		const maxCoord = max([scaledStart, scaledEnd]) - scaleValue(0);
-		if (axis.orient === "left" || axis.orient === "right") {
-			attributes.x1 = minCoord;
-			attributes.x2 = maxCoord;
-		} else {
-			attributes.y1 = minCoord;
-			attributes.y2 = maxCoord;
-		}
-		return attributes;
-	}
+    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;
+    }
+    static getKeyLineAttributes(axis, scaleValue) {
+        const attributes = {
+            x1: 0,
+            y1: 0,
+            x2: 0,
+            y2: 0
+        };
+        const scaledStart = scaleValue(scaleValue.domain()[0]);
+        const scaledEnd = scaleValue(scaleValue.domain()[1]);
+        const minCoord = min([scaledStart, scaledEnd]) - scaleValue(0);
+        const maxCoord = max([scaledStart, scaledEnd]) - scaleValue(0);
+        if (axis.orient === "left" || axis.orient === "right") {
+            attributes.x1 = minCoord;
+            attributes.x2 = maxCoord;
+        }
+        else {
+            attributes.y1 = minCoord;
+            attributes.y2 = maxCoord;
+        }
+        return attributes;
+    }
 }

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

@@ -3,23 +3,9 @@ import { BlockMargin, GridLineOptions, IAxisModel } from "../../../model/model";
 import { Block } from "../../block/block";
 import { Scales } from "../scale/scale";
 export declare class GridLine {
-	private static readonly gridLineClass;
-	static render(
-		block: Block,
-		options: GridLineOptions,
-		axes: IAxisModel,
-		blockSize: Size,
-		margin: BlockMargin,
-		scales: Scales
-	): void;
-	static update(
-		block: Block,
-		options: GridLineOptions,
-		axes: IAxisModel,
-		blockSize: Size,
-		margin: BlockMargin,
-		scales: Scales
-	): void;
-	private static renderLine;
-	private static clear;
+    private static readonly gridLineClass;
+    static render(block: Block, options: GridLineOptions, axes: IAxisModel, blockSize: Size, margin: BlockMargin, scales: Scales): void;
+    static update(block: Block, options: GridLineOptions, axes: IAxisModel, blockSize: Size, margin: BlockMargin, scales: Scales): void;
+    private static renderLine;
+    private static clear;
 }

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

@@ -1,39 +1,40 @@
 import { GridLineHelper } from "./gidLineHelper";
 export class GridLine {
-	static render(block, options, axes, blockSize, margin, scales) {
-		if (options.flag.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, options).style("display", (d, i, group) => {
-				return d === 0 ? "none" : "block";
-			});
-		}
-		if (options.flag.key) {
-			const lineAttributes = GridLineHelper.getKeyLineAttributes(axes.key, scales.value);
-			this.renderLine(block, axes.key, lineAttributes, options);
-		}
-	}
-	static update(block, options, axes, blockSize, margin, scales) {
-		this.clear(block, axes.key.cssClass, axes.value.cssClass);
-		this.render(block, options, axes, blockSize, margin, scales);
-	}
-	static renderLine(block, axis, lineAttributes, options) {
-		const gridLine = 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);
-		if (options.styles.dash.on) gridLine.style("stroke-dasharray", 3);
-		return gridLine;
-	}
-	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 render(block, options, axes, blockSize, margin, scales) {
+        if (options.flag.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, options).style("display", (d, i, group) => {
+                return d === 0 ? "none" : "block";
+            });
+        }
+        if (options.flag.key) {
+            const lineAttributes = GridLineHelper.getKeyLineAttributes(axes.key, scales.value);
+            this.renderLine(block, axes.key, lineAttributes, options);
+        }
+    }
+    static update(block, options, axes, blockSize, margin, scales) {
+        this.clear(block, axes.key.cssClass, axes.value.cssClass);
+        this.render(block, options, axes, blockSize, margin, scales);
+    }
+    static renderLine(block, axis, lineAttributes, options) {
+        const gridLine = 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);
+        if (options.styles.dash.on)
+            gridLine.style("stroke-dasharray", 3);
+        return gridLine;
+    }
+    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();
+    }
 }
 GridLine.gridLineClass = "grid-line";

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

@@ -5,44 +5,34 @@ import { Block } from "../../block/block";
 import { SelectionCondition } from "../../helpers/domHelper";
 import { ChartLegendEngineModel } from "./legendHelper";
 export interface LegendContentRenderingOptions {
-	wrapperClasses: string[];
-	shouldCropLabels: boolean;
-	blockModel: LegendBlockModel;
-	itemsOptions: {
-		wrapperClasses: string[];
-		markerClass: string;
-		labelClass: string;
-	};
+    wrapperClasses: string[];
+    shouldCropLabels: boolean;
+    blockModel: LegendBlockModel;
+    itemsOptions: {
+        wrapperClasses: string[];
+        markerClass: string;
+        labelClass: string;
+    };
 }
 export declare class Legend {
-	static get(): Legend;
-	static readonly objectClass = "legend-object";
-	static readonly labelClass = "legend-label";
-	static readonly label2DClass = "legend-2d-label";
-	static readonly labelPolarClass = "legend-polar-label";
-	static readonly labelIntervalClass = "legend-interval-label";
-	static readonly itemClass = "legend-item";
-	static readonly markerClass = "legend-marker";
-	static readonly markerCircle = "legend-circle";
-	static readonly legendBlockClass = "legend-block";
-	private readonly markerCreator;
-	render(
-		block: Block,
-		data: MdtChartsDataSource,
-		options: TwoDimensionalOptionsModel | PolarOptionsModel,
-		model: Model
-	): void;
-	update(block: Block, data: MdtChartsDataSource, model: Model<TwoDimensionalOptionsModel | PolarOptionsModel>): void;
-	updateColors(block: Block, options: TwoDimensionalOptionsModel | PolarOptionsModel): void;
-	static getItemsByKeys(
-		block: Block,
-		keys: string[],
-		condition?: SelectionCondition
-	): Selection<HTMLDivElement, ChartLegendEngineModel, BaseType, unknown>;
-	private setContent;
-	private renderObject;
-	private renderContent;
-	private getObject;
-	private removeContent;
-	private fillCoordinate;
+    static get(): Legend;
+    static readonly objectClass = "legend-object";
+    static readonly labelClass = "legend-label";
+    static readonly label2DClass = "legend-2d-label";
+    static readonly labelPolarClass = "legend-polar-label";
+    static readonly itemClass = "legend-item";
+    static readonly markerClass = "legend-marker";
+    static readonly markerCircle = "legend-circle";
+    static readonly legendBlockClass = "legend-block";
+    private readonly markerCreator;
+    render(block: Block, data: MdtChartsDataSource, options: TwoDimensionalOptionsModel | PolarOptionsModel, model: Model): void;
+    update(block: Block, data: MdtChartsDataSource, model: Model<TwoDimensionalOptionsModel | PolarOptionsModel>): void;
+    updateColors(block: Block, options: TwoDimensionalOptionsModel | PolarOptionsModel): void;
+    static getItemsByKeys(block: Block, keys: string[], condition?: SelectionCondition): Selection<HTMLDivElement, ChartLegendEngineModel, BaseType, unknown>;
+    private setContent;
+    private renderObject;
+    private renderContent;
+    private getObject;
+    private removeContent;
+    private fillCoordinate;
 }