mdt-charts 1.28.2 → 1.29.0

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

@@ -5,48 +5,87 @@ 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,144 +2,180 @@ 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,19 +1,18 @@
 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;
 }