mdt-charts 1.29.0 → 1.30.0

package/lib/engine/twoDimensionalNotation/bar/barHelper.d.ts

@@ -5,87 +5,48 @@ import { MdtChartsDataRow } from "../../../config/config";
 import { Pipeline } from "../../helpers/pipeline/Pipeline";
 import { BaseType, Selection } from "d3-selection";
 export interface BarAttrsHelper {
-	x: (dataRow: MdtChartsDataRow) => number;
-	y: (dataRow: MdtChartsDataRow) => number;
-	width: (dataRow: MdtChartsDataRow) => number;
-	height: (dataRow: MdtChartsDataRow) => number;
+    x: (dataRow: MdtChartsDataRow) => number;
+    y: (dataRow: MdtChartsDataRow) => number;
+    width: (dataRow: MdtChartsDataRow) => number;
+    height: (dataRow: MdtChartsDataRow) => number;
 }
 export interface GroupBarsSegment {
-	segmentIndex: number;
-	chart: TwoDimensionalChartModel;
+    segmentIndex: number;
+    chart: TwoDimensionalChartModel;
 }
 interface BandLikeChartSettingsStore {
-	getBandItemSize(): number;
-	getBandItemPad(bandItemIndex: number): number;
+    getBandItemSize(): number;
+    getBandItemPad(bandItemIndex: number): number;
 }
 export declare class DotChartSettingsStore implements BandLikeChartSettingsStore {
-	private readonly canvasConfig;
-	constructor(canvasConfig: { scaleBandWidth: number });
-	getBandItemSize(): number;
-	getBandItemPad(): number;
+    private readonly canvasConfig;
+    constructor(canvasConfig: {
+        scaleBandWidth: number;
+    });
+    getBandItemSize(): number;
+    getBandItemPad(): number;
 }
 export declare class BarSettingsStore {
-	private readonly modelSettings;
-	private readonly canvasConfig;
-	constructor(
-		modelSettings: BarChartSettings,
-		canvasConfig: {
-			scaleBandWidth: number;
-			barsAmount: number;
-		}
-	);
-	getBandItemSize(): number;
-	getBandItemPad(barIndex: number): number;
-	private getBarStep;
+    private readonly modelSettings;
+    private readonly canvasConfig;
+    constructor(modelSettings: BarChartSettings, canvasConfig: {
+        scaleBandWidth: number;
+        barsAmount: number;
+    });
+    getBandItemSize(): number;
+    getBandItemPad(barIndex: number): number;
+    private getBarStep;
 }
 export declare class BarHelper {
-	static getGroupedBarAttrs(
-		keyAxisOrient: Orient,
-		scales: Scales,
-		margin: BlockMargin,
-		keyField: string,
-		valueFieldName: string,
-		barIndex: number,
-		barsAmount: number,
-		barSettings: BarChartSettings
-	): BarAttrsHelper;
-	static getStackedBarAttr(
-		keyAxisOrient: Orient,
-		scales: Scales,
-		margin: BlockMargin,
-		keyField: string,
-		barIndex: number,
-		barsAmount: number,
-		barSettings: BarChartSettings
-	): BarAttrsHelper;
-	static getBarsInGroupAmount(charts: TwoDimensionalChartModel[]): number[];
-	static setBarAttrsByKey(
-		attrs: BarAttrsHelper,
-		keyAxisOrient: Orient,
-		scaleKey: AxisScale<any>,
-		margin: BlockMargin,
-		keyField: string,
-		barIndex: number,
-		settingsStore: BandLikeChartSettingsStore,
-		isSegmented: boolean
-	): void;
-	private static setGroupedBarAttrsByValue;
-	static getBandItemValueStretch(
-		scaleValue: AxisScale<any>,
-		valueFieldName: string
-	): (dataRow: MdtChartsDataRow) => number;
-	static setGroupedBandStartCoordinateAttr(
-		attrs: BarAttrsHelper,
-		keyAxisOrient: Orient,
-		scaleValue: AxisScale<any>,
-		margin: BlockMargin,
-		valueFieldName: string
-	): void;
-	private static setSegmentedBarAttrsByValue;
+    static getGroupedBarAttrs(keyAxisOrient: Orient, scales: Scales, margin: BlockMargin, keyField: string, valueFieldName: string, barIndex: number, barsAmount: number, barSettings: BarChartSettings): BarAttrsHelper;
+    static getStackedBarAttr(keyAxisOrient: Orient, scales: Scales, margin: BlockMargin, keyField: string, barIndex: number, barsAmount: number, barSettings: BarChartSettings): BarAttrsHelper;
+    static getBarsInGroupAmount(charts: TwoDimensionalChartModel[]): number[];
+    static setBarAttrsByKey(attrs: BarAttrsHelper, keyAxisOrient: Orient, scaleKey: AxisScale<any>, margin: BlockMargin, keyField: string, barIndex: number, settingsStore: BandLikeChartSettingsStore, isSegmented: boolean): void;
+    private static setGroupedBarAttrsByValue;
+    static getBandItemValueStretch(scaleValue: AxisScale<any>, valueFieldName: string): (dataRow: MdtChartsDataRow) => number;
+    static setGroupedBandStartCoordinateAttr(attrs: BarAttrsHelper, keyAxisOrient: Orient, scaleValue: AxisScale<any>, margin: BlockMargin, valueFieldName: string): void;
+    private static setSegmentedBarAttrsByValue;
 }
-export declare function onBarChartInit(
-	createBarPipeline: Pipeline<Selection<SVGRectElement, any, BaseType, any>, TwoDimensionalChartModel>,
-	createSegmentGroupBarsPipeline: Pipeline<Selection<SVGRectElement, any, BaseType, any>, GroupBarsSegment>
-): void;
+export declare function onBarChartInit(createBarPipeline: Pipeline<Selection<SVGRectElement, any, BaseType, any>, TwoDimensionalChartModel>, createSegmentGroupBarsPipeline: Pipeline<Selection<SVGRectElement, any, BaseType, any>, GroupBarsSegment>): void;
 export declare function getClipPathValue({ topLeft, topRight, bottomLeft, bottomRight }: BarBorderRadius): string;
 export {};

package/lib/engine/twoDimensionalNotation/bar/barHelper.js

@@ -2,180 +2,144 @@ import { Scale } from "../../features/scale/scale";
 import { Helper } from "../../helpers/helper";
 import { HatchPatternDef } from "../../block/defs/hatchPattern";
 export class DotChartSettingsStore {
-	constructor(canvasConfig) {
-		this.canvasConfig = canvasConfig;
-	}
-	getBandItemSize() {
-		return this.canvasConfig.scaleBandWidth;
-	}
-	getBandItemPad() {
-		return 0;
-	}
+    constructor(canvasConfig) {
+        this.canvasConfig = canvasConfig;
+    }
+    getBandItemSize() {
+        return this.canvasConfig.scaleBandWidth;
+    }
+    getBandItemPad() {
+        return 0;
+    }
 }
 export class BarSettingsStore {
-	constructor(modelSettings, canvasConfig) {
-		this.modelSettings = modelSettings;
-		this.canvasConfig = canvasConfig;
-	}
-	getBandItemSize() {
-		const barSize =
-			this.getBarStep() > this.modelSettings.maxBarWidth ? this.modelSettings.maxBarWidth : this.getBarStep();
-		return barSize;
-	}
-	getBandItemPad(barIndex) {
-		const barDiff = ((this.getBarStep() - this.getBandItemSize()) * this.canvasConfig.barsAmount) / 2; // if bar bigger than maxWidth, diff for x coordinate
-		const barPad = this.getBandItemSize() * barIndex + this.modelSettings.barDistance * barIndex + barDiff; // Отступ бара от края. Зависит от количества баров в одной группе и порядке текущего бара
-		return barPad;
-	}
-	getBarStep() {
-		return (
-			(this.canvasConfig.scaleBandWidth - this.modelSettings.barDistance * (this.canvasConfig.barsAmount - 1)) /
-			this.canvasConfig.barsAmount
-		); // Space for one bar
-	}
+    constructor(modelSettings, canvasConfig) {
+        this.modelSettings = modelSettings;
+        this.canvasConfig = canvasConfig;
+    }
+    getBandItemSize() {
+        const barSize = this.getBarStep() > this.modelSettings.maxBarWidth ? this.modelSettings.maxBarWidth : this.getBarStep();
+        return barSize;
+    }
+    getBandItemPad(barIndex) {
+        const barDiff = ((this.getBarStep() - this.getBandItemSize()) * this.canvasConfig.barsAmount) / 2; // if bar bigger than maxWidth, diff for x coordinate
+        const barPad = this.getBandItemSize() * barIndex + this.modelSettings.barDistance * barIndex + barDiff; // Отступ бара от края. Зависит от количества баров в одной группе и порядке текущего бара
+        return barPad;
+    }
+    getBarStep() {
+        return ((this.canvasConfig.scaleBandWidth - this.modelSettings.barDistance * (this.canvasConfig.barsAmount - 1)) /
+            this.canvasConfig.barsAmount); // Space for one bar
+    }
 }
 export class BarHelper {
-	static getGroupedBarAttrs(
-		keyAxisOrient,
-		scales,
-		margin,
-		keyField,
-		valueFieldName,
-		barIndex,
-		barsAmount,
-		barSettings
-	) {
-		const attrs = {
-			x: null,
-			y: null,
-			width: null,
-			height: null
-		};
-		this.setBarAttrsByKey(
-			attrs,
-			keyAxisOrient,
-			scales.key,
-			margin,
-			keyField,
-			barIndex,
-			new BarSettingsStore(barSettings, {
-				scaleBandWidth: Scale.getScaleBandWidth(scales.key),
-				barsAmount
-			}),
-			false
-		);
-		this.setGroupedBarAttrsByValue(attrs, keyAxisOrient, margin, scales.value, valueFieldName);
-		return attrs;
-	}
-	static getStackedBarAttr(keyAxisOrient, scales, margin, keyField, barIndex, barsAmount, barSettings) {
-		const attrs = {
-			x: null,
-			y: null,
-			width: null,
-			height: null
-		};
-		this.setBarAttrsByKey(
-			attrs,
-			keyAxisOrient,
-			scales.key,
-			margin,
-			keyField,
-			barIndex,
-			new BarSettingsStore(barSettings, {
-				scaleBandWidth: Scale.getScaleBandWidth(scales.key),
-				barsAmount
-			}),
-			true
-		);
-		this.setSegmentedBarAttrsByValue(attrs, keyAxisOrient, scales.value, margin);
-		return attrs;
-	}
-	static getBarsInGroupAmount(charts) {
-		let amounts = [];
-		charts.forEach((chart) => {
-			if (chart.type === "bar" && chart.isSegmented) amounts.push(1);
-			// Сегментированный бар содержит все свои valueFields в одном баре
-			else if (chart.type === "bar") amounts.push(chart.data.valueFields.length);
-		});
-		return amounts;
-	}
-	static setBarAttrsByKey(attrs, keyAxisOrient, scaleKey, margin, keyField, barIndex, settingsStore, isSegmented) {
-		if (keyAxisOrient === "top" || keyAxisOrient === "bottom") {
-			attrs.x = (d) =>
-				scaleKey(Helper.getKeyFieldValue(d, keyField, isSegmented)) +
-				margin.left +
-				settingsStore.getBandItemPad(barIndex);
-			attrs.width = (d) => settingsStore.getBandItemSize();
-		}
-		if (keyAxisOrient === "left" || keyAxisOrient === "right") {
-			attrs.y = (d) =>
-				scaleKey(Helper.getKeyFieldValue(d, keyField, isSegmented)) +
-				margin.top +
-				settingsStore.getBandItemPad(barIndex);
-			attrs.height = (d) => settingsStore.getBandItemSize();
-		}
-	}
-	static setGroupedBarAttrsByValue(attrs, keyAxisOrient, margin, scaleValue, valueFieldName) {
-		this.setGroupedBandStartCoordinateAttr(attrs, keyAxisOrient, scaleValue, margin, valueFieldName);
-		if (keyAxisOrient === "top" || keyAxisOrient === "bottom") {
-			attrs.height = this.getBandItemValueStretch(scaleValue, valueFieldName);
-		}
-		if (keyAxisOrient === "left" || keyAxisOrient === "right") {
-			attrs.width = this.getBandItemValueStretch(scaleValue, valueFieldName);
-		}
-	}
-	static getBandItemValueStretch(scaleValue, valueFieldName) {
-		return (d) => Math.abs(scaleValue(d[valueFieldName]) - scaleValue(0));
-	}
-	static setGroupedBandStartCoordinateAttr(attrs, keyAxisOrient, scaleValue, margin, valueFieldName) {
-		if (keyAxisOrient === "top") {
-			attrs.y = (d) => scaleValue(Math.min(d[valueFieldName], 0)) + margin.top;
-		}
-		if (keyAxisOrient === "bottom") {
-			attrs.y = (d) => scaleValue(Math.max(d[valueFieldName], 0)) + margin.top;
-		}
-		if (keyAxisOrient === "left") {
-			attrs.x = (d) => scaleValue(Math.min(d[valueFieldName], 0)) + margin.left;
-		}
-		if (keyAxisOrient === "right") {
-			attrs.x = (d) => scaleValue(Math.max(d[valueFieldName], 0)) + margin.left;
-		}
-	}
-	static setSegmentedBarAttrsByValue(attrs, keyAxisOrient, scaleValue, margin) {
-		if (keyAxisOrient === "top") {
-			attrs.y = (d) => scaleValue(Math.min(d[1], d[0])) + margin.top;
-			attrs.height = (d) => Math.abs(scaleValue(d[1]) - scaleValue(d[0]));
-		}
-		if (keyAxisOrient === "bottom") {
-			attrs.y = (d) => scaleValue(Math.max(d[1], d[0])) + margin.top;
-			attrs.height = (d) => Math.abs(scaleValue(d[1]) - scaleValue(d[0]));
-		}
-		if (keyAxisOrient === "left") {
-			attrs.x = (d) => scaleValue(Math.min(d[1], d[0])) + margin.left;
-			attrs.width = (d) => Math.abs(scaleValue(d[1]) - scaleValue(d[0]));
-		}
-		if (keyAxisOrient === "right") {
-			attrs.x = (d) => scaleValue(Math.max(d[1], d[0])) + margin.left;
-			attrs.width = (d) => Math.abs(scaleValue(d[1]) - scaleValue(d[0]));
-		}
-	}
+    static getGroupedBarAttrs(keyAxisOrient, scales, margin, keyField, valueFieldName, barIndex, barsAmount, barSettings) {
+        const attrs = {
+            x: null,
+            y: null,
+            width: null,
+            height: null
+        };
+        this.setBarAttrsByKey(attrs, keyAxisOrient, scales.key, margin, keyField, barIndex, new BarSettingsStore(barSettings, { scaleBandWidth: Scale.getScaleBandWidth(scales.key), barsAmount }), false);
+        this.setGroupedBarAttrsByValue(attrs, keyAxisOrient, margin, scales.value, valueFieldName);
+        return attrs;
+    }
+    static getStackedBarAttr(keyAxisOrient, scales, margin, keyField, barIndex, barsAmount, barSettings) {
+        const attrs = {
+            x: null,
+            y: null,
+            width: null,
+            height: null
+        };
+        this.setBarAttrsByKey(attrs, keyAxisOrient, scales.key, margin, keyField, barIndex, new BarSettingsStore(barSettings, { scaleBandWidth: Scale.getScaleBandWidth(scales.key), barsAmount }), true);
+        this.setSegmentedBarAttrsByValue(attrs, keyAxisOrient, scales.value, margin);
+        return attrs;
+    }
+    static getBarsInGroupAmount(charts) {
+        let amounts = [];
+        charts.forEach((chart) => {
+            if (chart.type === "bar" && chart.isSegmented)
+                amounts.push(1); // Сегментированный бар содержит все свои valueFields в одном баре
+            else if (chart.type === "bar")
+                amounts.push(chart.data.valueFields.length);
+        });
+        return amounts;
+    }
+    static setBarAttrsByKey(attrs, keyAxisOrient, scaleKey, margin, keyField, barIndex, settingsStore, isSegmented) {
+        if (keyAxisOrient === "top" || keyAxisOrient === "bottom") {
+            attrs.x = (d) => scaleKey(Helper.getKeyFieldValue(d, keyField, isSegmented)) +
+                margin.left +
+                settingsStore.getBandItemPad(barIndex);
+            attrs.width = (d) => settingsStore.getBandItemSize();
+        }
+        if (keyAxisOrient === "left" || keyAxisOrient === "right") {
+            attrs.y = (d) => scaleKey(Helper.getKeyFieldValue(d, keyField, isSegmented)) +
+                margin.top +
+                settingsStore.getBandItemPad(barIndex);
+            attrs.height = (d) => settingsStore.getBandItemSize();
+        }
+    }
+    static setGroupedBarAttrsByValue(attrs, keyAxisOrient, margin, scaleValue, valueFieldName) {
+        this.setGroupedBandStartCoordinateAttr(attrs, keyAxisOrient, scaleValue, margin, valueFieldName);
+        if (keyAxisOrient === "top" || keyAxisOrient === "bottom") {
+            attrs.height = this.getBandItemValueStretch(scaleValue, valueFieldName);
+        }
+        if (keyAxisOrient === "left" || keyAxisOrient === "right") {
+            attrs.width = this.getBandItemValueStretch(scaleValue, valueFieldName);
+        }
+    }
+    static getBandItemValueStretch(scaleValue, valueFieldName) {
+        return (d) => Math.abs(scaleValue(d[valueFieldName]) - scaleValue(0));
+    }
+    static setGroupedBandStartCoordinateAttr(attrs, keyAxisOrient, scaleValue, margin, valueFieldName) {
+        if (keyAxisOrient === "top") {
+            attrs.y = (d) => scaleValue(Math.min(d[valueFieldName], 0)) + margin.top;
+        }
+        if (keyAxisOrient === "bottom") {
+            attrs.y = (d) => scaleValue(Math.max(d[valueFieldName], 0)) + margin.top;
+        }
+        if (keyAxisOrient === "left") {
+            attrs.x = (d) => scaleValue(Math.min(d[valueFieldName], 0)) + margin.left;
+        }
+        if (keyAxisOrient === "right") {
+            attrs.x = (d) => scaleValue(Math.max(d[valueFieldName], 0)) + margin.left;
+        }
+    }
+    static setSegmentedBarAttrsByValue(attrs, keyAxisOrient, scaleValue, margin) {
+        if (keyAxisOrient === "top") {
+            attrs.y = (d) => scaleValue(Math.min(d[1], d[0])) + margin.top;
+            attrs.height = (d) => Math.abs(scaleValue(d[1]) - scaleValue(d[0]));
+        }
+        if (keyAxisOrient === "bottom") {
+            attrs.y = (d) => scaleValue(Math.max(d[1], d[0])) + margin.top;
+            attrs.height = (d) => Math.abs(scaleValue(d[1]) - scaleValue(d[0]));
+        }
+        if (keyAxisOrient === "left") {
+            attrs.x = (d) => scaleValue(Math.min(d[1], d[0])) + margin.left;
+            attrs.width = (d) => Math.abs(scaleValue(d[1]) - scaleValue(d[0]));
+        }
+        if (keyAxisOrient === "right") {
+            attrs.x = (d) => scaleValue(Math.max(d[1], d[0])) + margin.left;
+            attrs.width = (d) => Math.abs(scaleValue(d[1]) - scaleValue(d[0]));
+        }
+    }
 }
 export function onBarChartInit(createBarPipeline, createSegmentGroupBarsPipeline) {
-	createBarPipeline.push(hatchBar);
-	createBarPipeline.push(roundGroupedBars);
-	createSegmentGroupBarsPipeline.push(roundSegmentedBars);
+    createBarPipeline.push(hatchBar);
+    createBarPipeline.push(roundGroupedBars);
+    createSegmentGroupBarsPipeline.push(roundSegmentedBars);
 }
 function roundSegmentedBars(bars, segment) {
-	const radiusValues = segment.chart.barViewOptions.borderRadius.segmented.handle(segment.segmentIndex);
-	return bars.style("clip-path", getClipPathValue(radiusValues));
+    const radiusValues = segment.chart.barViewOptions.borderRadius.segmented.handle(segment.segmentIndex);
+    return bars.style("clip-path", getClipPathValue(radiusValues));
 }
 function roundGroupedBars(bars, chart) {
-	return bars.style("clip-path", getClipPathValue(chart.barViewOptions.borderRadius.grouped));
+    return bars.style("clip-path", getClipPathValue(chart.barViewOptions.borderRadius.grouped));
 }
 export function getClipPathValue({ topLeft, topRight, bottomLeft, bottomRight }) {
-	return `inset(0px round ${topLeft}px ${topRight}px ${bottomRight}px ${bottomLeft}px)`;
+    return `inset(0px round ${topLeft}px ${topRight}px ${bottomRight}px ${bottomLeft}px)`;
 }
 function hatchBar(bars, chart) {
-	if (chart.barViewOptions.hatch.on) bars.style("mask", HatchPatternDef.getMaskValue());
-	return bars;
+    if (chart.barViewOptions.hatch.on)
+        bars.style("mask", HatchPatternDef.getMaskValue());
+    return bars;
 }

package/lib/engine/twoDimensionalNotation/bar/stackedData/dataStacker.d.ts

@@ -1,15 +1,15 @@
 import { MdtChartsDataRow } from "../../../../config/config";
 export interface SegmentWithFieldName {
-	fieldName: string;
+    fieldName: string;
 }
 export interface StackedDataRow extends SegmentWithFieldName {
-	0: number;
-	1: number;
-	data: MdtChartsDataRow;
+    0: number;
+    1: number;
+    data: MdtChartsDataRow;
 }
 export declare type StackedDataFull = StackedDataRow[][];
 export declare class DataStacker {
-	private service;
-	getStackedData(rawData: MdtChartsDataRow[], valueFields: string[]): StackedDataFull;
+    private service;
+    getStackedData(rawData: MdtChartsDataRow[], valueFields: string[]): StackedDataFull;
 }
 export declare function getStackedDataWithOwn(rawData: MdtChartsDataRow[], valueFields: string[]): StackedDataFull;

package/lib/engine/twoDimensionalNotation/bar/stackedData/dataStacker.js

@@ -1,29 +1,29 @@
 import { DataStackerService } from "./dataStackerService";
 export class DataStacker {
-	constructor() {
-		this.service = new DataStackerService();
-	}
-	getStackedData(rawData, valueFields) {
-		const stackedData = [];
-		valueFields.forEach((vField, vfIndex) => {
-			const fieldStack = [];
-			rawData.forEach((dataRow, drIndex) => {
-				const valueFromData = dataRow[vField];
-				const value0 = this.service.getValue0(stackedData, vfIndex, drIndex, valueFromData);
-				const value1 = this.service.getValue1(value0, valueFromData);
-				fieldStack.push({
-					0: value0,
-					1: value1,
-					data: dataRow,
-					fieldName: vField
-				});
-			});
-			stackedData.push(fieldStack);
-		});
-		return stackedData;
-	}
+    constructor() {
+        this.service = new DataStackerService();
+    }
+    getStackedData(rawData, valueFields) {
+        const stackedData = [];
+        valueFields.forEach((vField, vfIndex) => {
+            const fieldStack = [];
+            rawData.forEach((dataRow, drIndex) => {
+                const valueFromData = dataRow[vField];
+                const value0 = this.service.getValue0(stackedData, vfIndex, drIndex, valueFromData);
+                const value1 = this.service.getValue1(value0, valueFromData);
+                fieldStack.push({
+                    "0": value0,
+                    "1": value1,
+                    data: dataRow,
+                    fieldName: vField
+                });
+            });
+            stackedData.push(fieldStack);
+        });
+        return stackedData;
+    }
 }
 export function getStackedDataWithOwn(rawData, valueFields) {
-	const stacker = new DataStacker();
-	return stacker.getStackedData(rawData, valueFields);
+    const stacker = new DataStacker();
+    return stacker.getStackedData(rawData, valueFields);
 }

package/lib/engine/twoDimensionalNotation/bar/stackedData/dataStackerService.d.ts

@@ -1,5 +1,5 @@
 import { StackedDataFull } from "./dataStacker";
 export declare class DataStackerService {
-	getValue0(stackedData: StackedDataFull, vfIndex: number, drIndex: number, valueFromData: number): number;
-	getValue1(value0: number, valueFromData: number): number;
+    getValue0(stackedData: StackedDataFull, vfIndex: number, drIndex: number, valueFromData: number): number;
+    getValue1(value0: number, valueFromData: number): number;
 }

package/lib/engine/twoDimensionalNotation/bar/stackedData/dataStackerService.js

@@ -1,18 +1,19 @@
 export class DataStackerService {
-	getValue0(stackedData, vfIndex, drIndex, valueFromData) {
-		if (vfIndex === 0) return 0;
-		for (let i = vfIndex - 1; i >= 0; i--) {
-			if (valueFromData === 0) {
-				return stackedData[i][drIndex][1];
-			}
-			const needed = stackedData[i][drIndex][1] >= 0 === valueFromData >= 0;
-			if (needed) {
-				return stackedData[i][drIndex][1];
-			}
-		}
-		return 0;
-	}
-	getValue1(value0, valueFromData) {
-		return value0 + valueFromData;
-	}
+    getValue0(stackedData, vfIndex, drIndex, valueFromData) {
+        if (vfIndex === 0)
+            return 0;
+        for (let i = vfIndex - 1; i >= 0; i--) {
+            if (valueFromData === 0) {
+                return stackedData[i][drIndex][1];
+            }
+            const needed = stackedData[i][drIndex][1] >= 0 === valueFromData >= 0;
+            if (needed) {
+                return stackedData[i][drIndex][1];
+            }
+        }
+        return 0;
+    }
+    getValue1(value0, valueFromData) {
+        return value0 + valueFromData;
+    }
 }

package/lib/engine/twoDimensionalNotation/dot/dotChart.d.ts

@@ -3,34 +3,34 @@ import { BarChartSettings, BlockMargin, Orient, TwoDimensionalChartModel } from
 import { Block } from "../../block/block";
 import { Scales } from "../../features/scale/scale";
 export interface CanvasDotChartOptions {
-	elementAccessors: {
-		getBlock: () => Block;
-	};
-	dataOptions: {
-		keyFieldName: string;
-	};
-	canvas: {
-		keyAxisOrient: Orient;
-	};
-	bandOptions: {
-		settings: BarChartSettings;
-	};
+    elementAccessors: {
+        getBlock: () => Block;
+    };
+    dataOptions: {
+        keyFieldName: string;
+    };
+    canvas: {
+        keyAxisOrient: Orient;
+    };
+    bandOptions: {
+        settings: BarChartSettings;
+    };
 }
 export interface DotItemAttrGetters {
-	x1: (dataRow: MdtChartsDataRow) => number;
-	y1: (dataRow: MdtChartsDataRow) => number;
-	x2: (dataRow: MdtChartsDataRow) => number;
-	y2: (dataRow: MdtChartsDataRow) => number;
+    x1: (dataRow: MdtChartsDataRow) => number;
+    y1: (dataRow: MdtChartsDataRow) => number;
+    x2: (dataRow: MdtChartsDataRow) => number;
+    y2: (dataRow: MdtChartsDataRow) => number;
 }
 /**
  * @alpha experimental feature. Need to refactor.
  */
 export declare class CanvasDotChart {
-	private readonly options;
-	private readonly dotChartItemClass;
-	private renderedChart;
-	constructor(options: CanvasDotChartOptions);
-	render(scales: Scales, chart: TwoDimensionalChartModel, records: MdtChartsDataRow[], margin: BlockMargin): void;
-	update(scales: Scales, newRecords: MdtChartsDataRow[], margin: BlockMargin): Promise<void>[];
-	private getAttrs;
+    private readonly options;
+    private readonly dotChartItemClass;
+    private renderedChart;
+    constructor(options: CanvasDotChartOptions);
+    render(scales: Scales, chart: TwoDimensionalChartModel, records: MdtChartsDataRow[], margin: BlockMargin): void;
+    update(scales: Scales, newRecords: MdtChartsDataRow[], margin: BlockMargin): Promise<void>[];
+    private getAttrs;
 }