mdt-charts 1.28.2 → 1.29.0

package/lib/engine/twoDimensionalNotation/dot/dotChart.js

@@ -7,118 +7,139 @@ import { BarHelper, DotChartSettingsStore } from "../bar/barHelper";
  * @alpha experimental feature. Need to refactor.
  */
 export class CanvasDotChart {
-    constructor(options) {
-        this.options = options;
-        this.dotChartItemClass = NamesHelper.getClassName("dot-chart-item");
-        this.renderedChart = undefined;
-    }
-    render(scales, chart, records, margin) {
-        if (this.renderedChart)
-            return;
-        const valueFieldIndex = 0;
-        const elements = this.options.elementAccessors
-            .getBlock()
-            .svg.getChartGroup(chart.index)
-            .selectAll(`.${this.dotChartItemClass}${Helper.getCssClassesLine(chart.cssClasses)}${Helper.getCssClassesLine(Helper.getCssClassesWithElementIndex(chart.cssClasses, valueFieldIndex))}`)
-            .data(records)
-            .enter()
-            .append("line")
-            .style("stroke-width", chart.dotViewOptions.shape.width)
-            .attr("class", this.dotChartItemClass);
-        const attrs = this.getAttrs(scales, chart, chart.data.valueFields[0], margin);
-        elements
-            .attr("x1", (d) => attrs.x1(d))
-            .attr("y1", (d) => attrs.y1(d))
-            .attr("x2", (d) => attrs.x2(d))
-            .attr("y2", (d) => attrs.y2(d));
-        DomHelper.setCssClasses(elements, Helper.getCssClassesWithElementIndex(chart.cssClasses, valueFieldIndex));
-        DomHelper.setChartStyle(elements, chart.style, valueFieldIndex, "stroke");
-        this.renderedChart = chart;
-    }
-    update(scales, newRecords, margin) {
-        if (!this.renderedChart)
-            return;
-        const valueFieldIndex = 0;
-        const elements = this.options.elementAccessors
-            .getBlock()
-            .svg.getChartGroup(this.renderedChart.index)
-            .selectAll(`.${this.dotChartItemClass}${Helper.getCssClassesLine(this.renderedChart.cssClasses)}${Helper.getCssClassesLine(Helper.getCssClassesWithElementIndex(this.renderedChart.cssClasses, valueFieldIndex))}`)
-            .data(newRecords);
-        elements.exit().remove();
-        const newElements = elements
-            .enter()
-            .append("line")
-            .style("stroke-width", this.renderedChart.dotViewOptions.shape.width)
-            .attr("class", this.dotChartItemClass);
-        const attrs = this.getAttrs(scales, this.renderedChart, this.renderedChart.data.valueFields[0], margin);
-        newElements
-            .attr("x1", (d) => attrs.x1(d))
-            .attr("y1", (d) => attrs.y1(d))
-            .attr("x2", (d) => attrs.x2(d))
-            .attr("y2", (d) => attrs.y2(d));
-        DomHelper.setCssClasses(newElements, Helper.getCssClassesWithElementIndex(this.renderedChart.cssClasses, valueFieldIndex));
-        DomHelper.setChartStyle(newElements, this.renderedChart.style, valueFieldIndex, "stroke");
-        return [
-            new Promise((resolve) => {
-                elements
-                    .interrupt()
-                    .transition()
-                    .duration(this.options.elementAccessors.getBlock().transitionManager.durations.chartUpdate)
-                    .attr("x1", (d) => attrs.x1(d))
-                    .attr("y1", (d) => attrs.y1(d))
-                    .attr("x2", (d) => attrs.x2(d))
-                    .attr("y2", (d) => attrs.y2(d))
-                    .on("end", () => resolve());
-            })
-        ];
-    }
-    getAttrs(scales, chart, field, margin) {
-        const attrs = {
-            x1: null,
-            y1: null,
-            x2: null,
-            y2: null
-        };
-        const settingsStore = new DotChartSettingsStore({ scaleBandWidth: Scale.getScaleBandWidth(scales.key) });
-        // TODO: refactor
-        if (this.options.canvas.keyAxisOrient === "top" || this.options.canvas.keyAxisOrient === "bottom") {
-            const handleBase = (d) => scales.key(Helper.getKeyFieldValue(d, this.options.dataOptions.keyFieldName, false)) +
-                margin.left +
-                settingsStore.getBandItemPad();
-            attrs.x1 = (d) => chart.dotViewOptions.shape.handleStartCoordinate(handleBase(d));
-            attrs.x2 = (d) => chart.dotViewOptions.shape.handleEndCoordinate(handleBase(d) + settingsStore.getBandItemSize());
-        }
-        if (this.options.canvas.keyAxisOrient === "left" || this.options.canvas.keyAxisOrient === "right") {
-            const handleBase = (d) => scales.key(Helper.getKeyFieldValue(d, this.options.dataOptions.keyFieldName, false)) +
-                margin.top +
-                settingsStore.getBandItemPad();
-            attrs.y1 = (d) => chart.dotViewOptions.shape.handleStartCoordinate(handleBase(d));
-            attrs.y2 = (d) => chart.dotViewOptions.shape.handleEndCoordinate(handleBase(d) + settingsStore.getBandItemSize());
-        }
-        if (this.options.canvas.keyAxisOrient === "top") {
-            attrs.y1 = (d) => scales.value(Math.min(d[field.name], 0)) +
-                margin.top +
-                BarHelper.getBandItemValueStretch(scales.value, field.name)(d);
-            attrs.y2 = (d) => scales.value(Math.min(d[field.name], 0)) +
-                margin.top +
-                BarHelper.getBandItemValueStretch(scales.value, field.name)(d);
-        }
-        if (this.options.canvas.keyAxisOrient === "bottom") {
-            attrs.y1 = (d) => scales.value(Math.max(d[field.name], 0)) + margin.top;
-            attrs.y2 = (d) => scales.value(Math.max(d[field.name], 0)) + margin.top;
-        }
-        if (this.options.canvas.keyAxisOrient === "left") {
-            attrs.x1 = (d) => scales.value(Math.min(d[field.name], 0)) +
-                margin.left +
-                BarHelper.getBandItemValueStretch(scales.value, field.name)(d);
-            attrs.x2 = (d) => scales.value(Math.min(d[field.name], 0)) +
-                margin.left +
-                BarHelper.getBandItemValueStretch(scales.value, field.name)(d);
-        }
-        if (this.options.canvas.keyAxisOrient === "right") {
-            attrs.x1 = (d) => scales.value(Math.max(d[field.name], 0)) + margin.left;
-            attrs.x2 = (d) => scales.value(Math.max(d[field.name], 0)) + margin.left;
-        }
-        return attrs;
-    }
+	constructor(options) {
+		this.options = options;
+		this.dotChartItemClass = NamesHelper.getClassName("dot-chart-item");
+		this.renderedChart = undefined;
+	}
+	render(scales, chart, records, margin) {
+		if (this.renderedChart) return;
+		const valueFieldIndex = 0;
+		const elements = this.options.elementAccessors
+			.getBlock()
+			.svg.getChartGroup(chart.index)
+			.selectAll(
+				`.${this.dotChartItemClass}${Helper.getCssClassesLine(chart.cssClasses)}${Helper.getCssClassesLine(
+					Helper.getCssClassesWithElementIndex(chart.cssClasses, valueFieldIndex)
+				)}`
+			)
+			.data(records)
+			.enter()
+			.append("line")
+			.style("stroke-width", chart.dotViewOptions.shape.width)
+			.attr("class", this.dotChartItemClass);
+		const attrs = this.getAttrs(scales, chart, chart.data.valueFields[0], margin);
+		elements
+			.attr("x1", (d) => attrs.x1(d))
+			.attr("y1", (d) => attrs.y1(d))
+			.attr("x2", (d) => attrs.x2(d))
+			.attr("y2", (d) => attrs.y2(d));
+		DomHelper.setCssClasses(elements, Helper.getCssClassesWithElementIndex(chart.cssClasses, valueFieldIndex));
+		DomHelper.setChartStyle(elements, chart.style, valueFieldIndex, "stroke");
+		this.renderedChart = chart;
+	}
+	update(scales, newRecords, margin) {
+		if (!this.renderedChart) return;
+		const valueFieldIndex = 0;
+		const elements = this.options.elementAccessors
+			.getBlock()
+			.svg.getChartGroup(this.renderedChart.index)
+			.selectAll(
+				`.${this.dotChartItemClass}${Helper.getCssClassesLine(
+					this.renderedChart.cssClasses
+				)}${Helper.getCssClassesLine(
+					Helper.getCssClassesWithElementIndex(this.renderedChart.cssClasses, valueFieldIndex)
+				)}`
+			)
+			.data(newRecords);
+		elements.exit().remove();
+		const newElements = elements
+			.enter()
+			.append("line")
+			.style("stroke-width", this.renderedChart.dotViewOptions.shape.width)
+			.attr("class", this.dotChartItemClass);
+		const attrs = this.getAttrs(scales, this.renderedChart, this.renderedChart.data.valueFields[0], margin);
+		newElements
+			.attr("x1", (d) => attrs.x1(d))
+			.attr("y1", (d) => attrs.y1(d))
+			.attr("x2", (d) => attrs.x2(d))
+			.attr("y2", (d) => attrs.y2(d));
+		DomHelper.setCssClasses(
+			newElements,
+			Helper.getCssClassesWithElementIndex(this.renderedChart.cssClasses, valueFieldIndex)
+		);
+		DomHelper.setChartStyle(newElements, this.renderedChart.style, valueFieldIndex, "stroke");
+		return [
+			new Promise((resolve) => {
+				elements
+					.interrupt()
+					.transition()
+					.duration(this.options.elementAccessors.getBlock().transitionManager.durations.chartUpdate)
+					.attr("x1", (d) => attrs.x1(d))
+					.attr("y1", (d) => attrs.y1(d))
+					.attr("x2", (d) => attrs.x2(d))
+					.attr("y2", (d) => attrs.y2(d))
+					.on("end", () => resolve());
+			})
+		];
+	}
+	getAttrs(scales, chart, field, margin) {
+		const attrs = {
+			x1: null,
+			y1: null,
+			x2: null,
+			y2: null
+		};
+		const settingsStore = new DotChartSettingsStore({
+			scaleBandWidth: Scale.getScaleBandWidth(scales.key)
+		});
+		// TODO: refactor
+		if (this.options.canvas.keyAxisOrient === "top" || this.options.canvas.keyAxisOrient === "bottom") {
+			const handleBase = (d) =>
+				scales.key(Helper.getKeyFieldValue(d, this.options.dataOptions.keyFieldName, false)) +
+				margin.left +
+				settingsStore.getBandItemPad();
+			attrs.x1 = (d) => chart.dotViewOptions.shape.handleStartCoordinate(handleBase(d));
+			attrs.x2 = (d) =>
+				chart.dotViewOptions.shape.handleEndCoordinate(handleBase(d) + settingsStore.getBandItemSize());
+		}
+		if (this.options.canvas.keyAxisOrient === "left" || this.options.canvas.keyAxisOrient === "right") {
+			const handleBase = (d) =>
+				scales.key(Helper.getKeyFieldValue(d, this.options.dataOptions.keyFieldName, false)) +
+				margin.top +
+				settingsStore.getBandItemPad();
+			attrs.y1 = (d) => chart.dotViewOptions.shape.handleStartCoordinate(handleBase(d));
+			attrs.y2 = (d) =>
+				chart.dotViewOptions.shape.handleEndCoordinate(handleBase(d) + settingsStore.getBandItemSize());
+		}
+		if (this.options.canvas.keyAxisOrient === "top") {
+			attrs.y1 = (d) =>
+				scales.value(Math.min(d[field.name], 0)) +
+				margin.top +
+				BarHelper.getBandItemValueStretch(scales.value, field.name)(d);
+			attrs.y2 = (d) =>
+				scales.value(Math.min(d[field.name], 0)) +
+				margin.top +
+				BarHelper.getBandItemValueStretch(scales.value, field.name)(d);
+		}
+		if (this.options.canvas.keyAxisOrient === "bottom") {
+			attrs.y1 = (d) => scales.value(Math.max(d[field.name], 0)) + margin.top;
+			attrs.y2 = (d) => scales.value(Math.max(d[field.name], 0)) + margin.top;
+		}
+		if (this.options.canvas.keyAxisOrient === "left") {
+			attrs.x1 = (d) =>
+				scales.value(Math.min(d[field.name], 0)) +
+				margin.left +
+				BarHelper.getBandItemValueStretch(scales.value, field.name)(d);
+			attrs.x2 = (d) =>
+				scales.value(Math.min(d[field.name], 0)) +
+				margin.left +
+				BarHelper.getBandItemValueStretch(scales.value, field.name)(d);
+		}
+		if (this.options.canvas.keyAxisOrient === "right") {
+			attrs.x1 = (d) => scales.value(Math.max(d[field.name], 0)) + margin.left;
+			attrs.x2 = (d) => scales.value(Math.max(d[field.name], 0)) + margin.left;
+		}
+		return attrs;
+	}
 }

package/lib/engine/twoDimensionalNotation/extenders/twoDimRecordOverflowAlert.d.ts

@@ -1,15 +1,15 @@
 import { ChartOrientation } from "../../../config/config";
 import { Block } from "../../block/block";
 interface TwoDimRecordOverflowAlertOptions {
-    hidedRecordsAmount: number;
-    chartOrientation: ChartOrientation;
+	hidedRecordsAmount: number;
+	chartOrientation: ChartOrientation;
 }
 declare class TwoDimRecordOverflowAlertClass {
-    render(block: Block, options: TwoDimRecordOverflowAlertOptions): void;
-    update(block: Block, options: TwoDimRecordOverflowAlertOptions): void;
-    private buildCoreOptions;
-    private getText;
-    private getPositionAttrs;
+	render(block: Block, options: TwoDimRecordOverflowAlertOptions): void;
+	update(block: Block, options: TwoDimRecordOverflowAlertOptions): void;
+	private buildCoreOptions;
+	private getText;
+	private getPositionAttrs;
 }
 export declare const TwoDimRecordOverflowAlert: TwoDimRecordOverflowAlertClass;
 export {};

package/lib/engine/twoDimensionalNotation/extenders/twoDimRecordOverflowAlert.js

@@ -1,32 +1,32 @@
 import { RecordOverflowAlertCore } from "../../features/recordOverflowAlert/recordOverflowAlertCore";
 class TwoDimRecordOverflowAlertClass {
-    render(block, options) {
-        RecordOverflowAlertCore.render(block, this.buildCoreOptions(options));
-    }
-    update(block, options) {
-        RecordOverflowAlertCore.update(block, this.buildCoreOptions(options));
-    }
-    buildCoreOptions(options) {
-        return {
-            hidedRecordsAmount: options.hidedRecordsAmount,
-            text: this.getText(options.chartOrientation),
-            positionAttrs: this.getPositionAttrs()
-        };
-    }
-    getText(chartOrientation) {
-        const isHorizontal = chartOrientation === "horizontal";
-        return {
-            one: isHorizontal ? "строка" : "столбец",
-            twoToFour: isHorizontal ? "строки" : "столбца",
-            tenToTwenty: isHorizontal ? "строк" : "столбцов",
-            other: isHorizontal ? "строк" : "столбцов"
-        };
-    }
-    getPositionAttrs() {
-        return {
-            right: "0px",
-            top: "0px"
-        };
-    }
+	render(block, options) {
+		RecordOverflowAlertCore.render(block, this.buildCoreOptions(options));
+	}
+	update(block, options) {
+		RecordOverflowAlertCore.update(block, this.buildCoreOptions(options));
+	}
+	buildCoreOptions(options) {
+		return {
+			hidedRecordsAmount: options.hidedRecordsAmount,
+			text: this.getText(options.chartOrientation),
+			positionAttrs: this.getPositionAttrs()
+		};
+	}
+	getText(chartOrientation) {
+		const isHorizontal = chartOrientation === "horizontal";
+		return {
+			one: isHorizontal ? "строка" : "столбец",
+			twoToFour: isHorizontal ? "строки" : "столбца",
+			tenToTwenty: isHorizontal ? "строк" : "столбцов",
+			other: isHorizontal ? "строк" : "столбцов"
+		};
+	}
+	getPositionAttrs() {
+		return {
+			right: "0px",
+			top: "0px"
+		};
+	}
 }
 export const TwoDimRecordOverflowAlert = new TwoDimRecordOverflowAlertClass();

package/lib/engine/twoDimensionalNotation/line/line.d.ts

@@ -6,23 +6,44 @@ import { Block } from "../../block/block";
 import { MdtChartsDataRow } from "../../../config/config";
 import { Pipeline } from "../../helpers/pipeline/Pipeline";
 interface LineChartOptions {
-    staticSettings: LineLikeChartSettings;
+	staticSettings: LineLikeChartSettings;
 }
 export declare class Line {
-    private options;
-    static readonly lineChartClass = "line";
-    readonly creatingPipeline: Pipeline<Selection<SVGPathElement, any, BaseType, any>, TwoDimensionalChartModel>;
-    private readonly lineChartClass;
-    static get(options: LineChartOptions): Line;
-    constructor(options: LineChartOptions);
-    render(block: Block, scales: Scales, data: MdtChartsDataRow[], keyField: Field, margin: BlockMargin, keyAxisOrient: Orient, chart: TwoDimensionalChartModel): void;
-    update(block: Block, scales: Scales, newData: MdtChartsDataRow[], keyField: Field, margin: BlockMargin, keyAxisOrient: Orient, chart: TwoDimensionalChartModel): Promise<any>[];
-    updateColors(block: Block, chart: TwoDimensionalChartModel): void;
-    private renderGrouped;
-    private renderSegmented;
-    private updateGrouped;
-    private updateSegmented;
-    static updateGroupedPath(block: Block, lineObject: Selection<BaseType, any, BaseType, any>, lineGenerator: ILine<MdtChartsDataRow>, newData: MdtChartsDataRow[]): Promise<any>;
-    private createLineGeneratorFactory;
+	private options;
+	static readonly lineChartClass = "line";
+	readonly creatingPipeline: Pipeline<Selection<SVGPathElement, any, BaseType, any>, TwoDimensionalChartModel>;
+	private readonly lineChartClass;
+	static get(options: LineChartOptions): Line;
+	constructor(options: LineChartOptions);
+	render(
+		block: Block,
+		scales: Scales,
+		data: MdtChartsDataRow[],
+		keyField: Field,
+		margin: BlockMargin,
+		keyAxisOrient: Orient,
+		chart: TwoDimensionalChartModel
+	): void;
+	update(
+		block: Block,
+		scales: Scales,
+		newData: MdtChartsDataRow[],
+		keyField: Field,
+		margin: BlockMargin,
+		keyAxisOrient: Orient,
+		chart: TwoDimensionalChartModel
+	): Promise<any>[];
+	updateColors(block: Block, chart: TwoDimensionalChartModel): void;
+	private renderGrouped;
+	private renderSegmented;
+	private updateGrouped;
+	private updateSegmented;
+	static updateGroupedPath(
+		block: Block,
+		lineObject: Selection<BaseType, any, BaseType, any>,
+		lineGenerator: ILine<MdtChartsDataRow>,
+		newData: MdtChartsDataRow[]
+	): Promise<any>;
+	private createLineGeneratorFactory;
 }
 export {};