mdt-charts 1.29.0 → 1.30.0

package/lib/model/dataManagerModel/dataManagerModel.d.ts

@@ -3,42 +3,32 @@ import { DesignerConfig } from "../../designer/designerConfig";
 import { LegendBlockModel } from "../model";
 import { ModelInstance } from "../modelInstance/modelInstance";
 export interface DataLegendParams {
-	amount: number;
-	size: {
-		width: number;
-		height: number;
-	};
+    amount: number;
+    size: {
+        width: number;
+        height: number;
+    };
 }
 export declare class DataManagerModel {
-	private static service;
-	private static polarMarginCalculator;
-	static getPreparedData(
-		data: MdtChartsDataSource,
-		allowableKeys: string[],
-		config: MdtChartsConfig
-	): MdtChartsDataSource;
-	static initDataScope(
-		config: MdtChartsConfig,
-		data: MdtChartsDataSource,
-		designerConfig: DesignerConfig,
-		legendBlock: LegendBlockModel,
-		modelInstance: ModelInstance
-	): void;
-	private static initScopedData;
-	static getDataValuesByKeyField(data: MdtChartsDataSource, dataSourceName: string, keyFieldName: string): string[];
-	private static initDataScopeFor2D;
-	private static initDataScopeForPolar;
-	private static getLegendDataParams;
-	private static getMaximumPossibleScope;
-	private static limitAllowableKeys;
-	/**
-	 * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
-	 * @param configOptions
-	 * @param chartsLength
-	 */
-	private static getElementsInGroupAmount;
-	private static getBarLikeChartsInGroupAmount;
-	private static getScopedData;
-	private static getScopedChartData;
-	private static getDataLimitByItemSize;
+    private static service;
+    private static polarMarginCalculator;
+    static getPreparedData(data: MdtChartsDataSource, allowableKeys: string[], config: MdtChartsConfig): MdtChartsDataSource;
+    static initDataScope(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig, legendBlock: LegendBlockModel, modelInstance: ModelInstance): void;
+    private static initScopedData;
+    static getDataValuesByKeyField(data: MdtChartsDataSource, dataSourceName: string, keyFieldName: string): string[];
+    private static initDataScopeFor2D;
+    private static initDataScopeForPolar;
+    private static getLegendDataParams;
+    private static getMaximumPossibleScope;
+    private static limitAllowableKeys;
+    /**
+     * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
+     * @param configOptions
+     * @param chartsLength
+     */
+    private static getElementsInGroupAmount;
+    private static getBarLikeChartsInGroupAmount;
+    private static getScopedData;
+    private static getScopedChartData;
+    private static getDataLimitByItemSize;
 }

package/lib/model/dataManagerModel/dataManagerModel.js

@@ -6,185 +6,134 @@ import { DataManagerModelService } from "./dataManagerModelService";
 import { LegendPolarMarginCalculator } from "../featuresModel/legendModel/polarMarginCalculator";
 import { styledElementValues } from "../modelBuilder";
 export class DataManagerModel {
-	static getPreparedData(data, allowableKeys, config) {
-		const scopedData = this.getScopedData(data, allowableKeys, config.options.data);
-		return scopedData;
-	}
-	static initDataScope(config, data, designerConfig, legendBlock, modelInstance) {
-		if (config.options.type === "2d") {
-			this.initDataScopeFor2D(config.options, modelInstance, data, designerConfig);
-		} else if (config.options.type === "polar") {
-			this.initDataScopeForPolar(
-				config.options,
-				modelInstance,
-				data,
-				legendBlock,
-				designerConfig.canvas.legendBlock
-			);
-		}
-		this.initScopedData(data, modelInstance, config);
-	}
-	static initScopedData(data, modelInstance, config) {
-		const preparedData = DataManagerModel.getPreparedData(data, modelInstance.dataModel.getAllowableKeys(), config);
-		modelInstance.dataModel.repository.initScopedFullSource(preparedData);
-	}
-	static getDataValuesByKeyField(data, dataSourceName, keyFieldName) {
-		return data[dataSourceName].map((dataRow) => dataRow[keyFieldName]);
-	}
-	static initDataScopeFor2D(configOptions, modelInstance, data, designerConfig) {
-		modelInstance.dataModel.initMaxRecordsAmount(configOptions.data.maxRecordsAmount);
-		const axisLength = AxisModel.getAxisLength(configOptions.orientation, modelInstance.canvasModel);
-		const uniqueKeys = ModelHelper.getUniqueValues(
-			data[configOptions.data.dataSource].map((d) => d[configOptions.data.keyField.name])
-		);
-		const dataLength = uniqueKeys.length;
-		const limit = this.getDataLimitByItemSize(
-			this.getElementsInGroupAmount(configOptions),
-			dataLength,
-			axisLength,
-			designerConfig.canvas.chartOptions.bar
-		);
-		const allowableKeys = uniqueKeys.slice(0, limit);
-		const hidedRecordsAmount = dataLength - allowableKeys.length;
-		modelInstance.dataModel.initScope(
-			this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel)
-		);
-	}
-	static initDataScopeForPolar(configOptions, modelInstance, data, legendBlock, legendCanvas) {
-		modelInstance.dataModel.initMaxRecordsAmount(configOptions.data.maxRecordsAmount);
-		const canvasModel = modelInstance.canvasModel;
-		const keyFieldName = configOptions.data.keyField.name;
-		const keys = data[configOptions.data.dataSource].map((dataRow) => dataRow[keyFieldName]);
-		if (!configOptions.legend.show) {
-			canvasModel.legendCanvas.setPosition("off");
-			modelInstance.dataModel.initScope(this.getMaximumPossibleScope(keys, modelInstance.dataModel));
-			return;
-		}
-		let position = PolarModel.getLegendPositionByBlockSize(modelInstance.canvasModel);
-		let { amount: maxItemsNumber, size } = this.getLegendDataParams(
-			position,
-			keys,
-			legendCanvas,
-			canvasModel,
-			legendBlock
-		);
-		if (
-			position === "right" &&
-			!PolarModel.doesChartBlockHasEnoughWidthForContainsLegend(
-				canvasModel.getChartBlockWidth(),
-				size.width,
-				legendBlock.coordinate
-			)
-		) {
-			const doesFreeSpaceExist = PolarModel.doesChartBlockHasEnoughHeightForContainsLegend(
-				canvasModel.getChartBlockHeight(),
-				legendBlock.coordinate
-			);
-			if (doesFreeSpaceExist) {
-				const newParams = this.getLegendDataParams("bottom", keys, legendCanvas, canvasModel, legendBlock);
-				position = "bottom";
-				maxItemsNumber = newParams.amount;
-				size = newParams.size;
-			}
-		}
-		//TODO: global refactor of method
-		const allowableKeys = keys.slice(0, maxItemsNumber);
-		const hidedRecordsAmount = keys.length - maxItemsNumber;
-		canvasModel.legendCanvas.setPosition(position);
-		this.polarMarginCalculator.updateMargin(
-			position,
-			canvasModel,
-			legendBlock,
-			position === "bottom" ? size.height : size.width
-		);
-		modelInstance.dataModel.initScope(
-			this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel)
-		);
-	}
-	//TODO: position type
-	static getLegendDataParams(position, keys, legendCanvas, canvasModel, legendBlock) {
-		const legendItemContentOptions = keys.map((k) => ({
-			text: k,
-			markerSize: styledElementValues.defaultLegendMarkerSizes,
-			wrapperSize: {
-				marginRightPx: styledElementValues.legend.inlineDynamicItemWrapperMarginRightPx
-			}
-		}));
-		if (position === "right") {
-			return LegendCanvasModel.findElementsAmountByLegendSize(
-				legendItemContentOptions,
-				position,
-				this.polarMarginCalculator.getMaxLegendWidth(legendCanvas, canvasModel.getBlockSize().width),
-				canvasModel.getChartBlockHeight() - legendBlock.coordinate.right.margin.bottom
-			);
-		} else {
-			return LegendCanvasModel.findElementsAmountByLegendSize(
-				legendItemContentOptions,
-				position,
-				canvasModel.getChartBlockWidth() -
-					legendBlock.coordinate.bottom.margin.left -
-					legendBlock.coordinate.bottom.margin.right,
-				canvasModel.getChartBlockHeight() -
-					legendBlock.coordinate.bottom.margin.bottom -
-					legendBlock.coordinate.bottom.margin.top -
-					MIN_DONUT_BLOCK_SIZE
-			);
-		}
-	}
-	static getMaximumPossibleScope(keys, dataModel) {
-		return this.service.getMaximumPossibleAmount(keys, dataModel.getMaxRecordsAmount());
-	}
-	static limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel) {
-		return this.service.limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel.getMaxRecordsAmount());
-	}
-	/**
-	 * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
-	 * @param configOptions
-	 * @param chartsLength
-	 */
-	static getElementsInGroupAmount(configOptions) {
-		const bars = this.getBarLikeChartsInGroupAmount(configOptions.charts, "bar");
-		const dots = configOptions.charts.some((chart) => chart.type === "dot") ? 1 : 0;
-		return Math.max(bars, dots);
-	}
-	static getBarLikeChartsInGroupAmount(charts, type) {
-		let barsAmount = 0;
-		charts.forEach((chart) => {
-			if (chart.type === type && chart.isSegmented)
-				barsAmount += 1; // в сегментированном баре все valueFields находятся внутри одного бара, поэтому бар всегда один.
-			else if (chart.type === type) barsAmount += chart.data.valueFields.length;
-		});
-		return barsAmount;
-	}
-	static getScopedData(data, allowableKeys, dataOptions) {
-		const newData = {};
-		newData[dataOptions.dataSource] = this.getScopedChartData(
-			data[dataOptions.dataSource],
-			allowableKeys,
-			dataOptions.keyField.name
-		);
-		return newData;
-	}
-	static getScopedChartData(data, allowableKeys, keyFieldName) {
-		return data.filter((d) => allowableKeys.findIndex((key) => key === d[keyFieldName]) !== -1);
-	}
-	static getDataLimitByItemSize(elementsInGroupAmount, dataLength, axisLength, barOptions) {
-		let sumSize =
-			dataLength *
-			(elementsInGroupAmount * barOptions.minBarWidth +
-				(elementsInGroupAmount - 1) * barOptions.barDistance +
-				barOptions.groupMinDistance);
-		while (dataLength !== 0 && axisLength < sumSize) {
-			dataLength--;
-			// find whole space for bars in group + distance between bars + group distance
-			sumSize =
-				dataLength *
-				(elementsInGroupAmount * barOptions.minBarWidth +
-					(elementsInGroupAmount - 1) * barOptions.barDistance +
-					barOptions.groupMinDistance);
-		}
-		return dataLength;
-	}
+    static getPreparedData(data, allowableKeys, config) {
+        const scopedData = this.getScopedData(data, allowableKeys, config.options.data);
+        return scopedData;
+    }
+    static initDataScope(config, data, designerConfig, legendBlock, modelInstance) {
+        if (config.options.type === "2d") {
+            this.initDataScopeFor2D(config.options, modelInstance, data, designerConfig);
+        }
+        else if (config.options.type === "polar") {
+            this.initDataScopeForPolar(config.options, modelInstance, data, legendBlock, designerConfig.canvas.legendBlock);
+        }
+        this.initScopedData(data, modelInstance, config);
+    }
+    static initScopedData(data, modelInstance, config) {
+        const preparedData = DataManagerModel.getPreparedData(data, modelInstance.dataModel.getAllowableKeys(), config);
+        modelInstance.dataModel.repository.initScopedFullSource(preparedData);
+    }
+    static getDataValuesByKeyField(data, dataSourceName, keyFieldName) {
+        return data[dataSourceName].map((dataRow) => dataRow[keyFieldName]);
+    }
+    static initDataScopeFor2D(configOptions, modelInstance, data, designerConfig) {
+        modelInstance.dataModel.initMaxRecordsAmount(configOptions.data.maxRecordsAmount);
+        const axisLength = AxisModel.getAxisLength(configOptions.orientation, modelInstance.canvasModel);
+        const uniqueKeys = ModelHelper.getUniqueValues(data[configOptions.data.dataSource].map((d) => d[configOptions.data.keyField.name]));
+        const dataLength = uniqueKeys.length;
+        const limit = this.getDataLimitByItemSize(this.getElementsInGroupAmount(configOptions), dataLength, axisLength, designerConfig.canvas.chartOptions.bar);
+        const allowableKeys = uniqueKeys.slice(0, limit);
+        const hidedRecordsAmount = dataLength - allowableKeys.length;
+        modelInstance.dataModel.initScope(this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel));
+    }
+    static initDataScopeForPolar(configOptions, modelInstance, data, legendBlock, legendCanvas) {
+        modelInstance.dataModel.initMaxRecordsAmount(configOptions.data.maxRecordsAmount);
+        const canvasModel = modelInstance.canvasModel;
+        const keyFieldName = configOptions.data.keyField.name;
+        const keys = data[configOptions.data.dataSource].map((dataRow) => dataRow[keyFieldName]);
+        if (!configOptions.legend.show) {
+            canvasModel.legendCanvas.setPosition("off");
+            modelInstance.dataModel.initScope(this.getMaximumPossibleScope(keys, modelInstance.dataModel));
+            return;
+        }
+        let position = PolarModel.getLegendPositionByBlockSize(modelInstance.canvasModel);
+        let { amount: maxItemsNumber, size } = this.getLegendDataParams(position, keys, legendCanvas, canvasModel, legendBlock);
+        if (position === "right" &&
+            !PolarModel.doesChartBlockHasEnoughWidthForContainsLegend(canvasModel.getChartBlockWidth(), size.width, legendBlock.coordinate)) {
+            const doesFreeSpaceExist = PolarModel.doesChartBlockHasEnoughHeightForContainsLegend(canvasModel.getChartBlockHeight(), legendBlock.coordinate);
+            if (doesFreeSpaceExist) {
+                const newParams = this.getLegendDataParams("bottom", keys, legendCanvas, canvasModel, legendBlock);
+                position = "bottom";
+                maxItemsNumber = newParams.amount;
+                size = newParams.size;
+            }
+        }
+        //TODO: global refactor of method
+        const allowableKeys = keys.slice(0, maxItemsNumber);
+        const hidedRecordsAmount = keys.length - maxItemsNumber;
+        canvasModel.legendCanvas.setPosition(position);
+        this.polarMarginCalculator.updateMargin(position, canvasModel, legendBlock, position === "bottom" ? size.height : size.width);
+        modelInstance.dataModel.initScope(this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel));
+    }
+    //TODO: position type
+    static getLegendDataParams(position, keys, legendCanvas, canvasModel, legendBlock) {
+        const legendItemContentOptions = keys.map((k) => ({
+            text: k,
+            markerSize: styledElementValues.defaultLegendMarkerSizes,
+            wrapperSize: { marginRightPx: styledElementValues.legend.inlineDynamicItemWrapperMarginRightPx }
+        }));
+        if (position === "right") {
+            return LegendCanvasModel.findElementsAmountByLegendSize(legendItemContentOptions, position, this.polarMarginCalculator.getMaxLegendWidth(legendCanvas, canvasModel.getBlockSize().width), canvasModel.getChartBlockHeight() - legendBlock.coordinate.right.margin.bottom);
+        }
+        else {
+            return LegendCanvasModel.findElementsAmountByLegendSize(legendItemContentOptions, position, canvasModel.getChartBlockWidth() -
+                legendBlock.coordinate.bottom.margin.left -
+                legendBlock.coordinate.bottom.margin.right, canvasModel.getChartBlockHeight() -
+                legendBlock.coordinate.bottom.margin.bottom -
+                legendBlock.coordinate.bottom.margin.top -
+                MIN_DONUT_BLOCK_SIZE);
+        }
+    }
+    static getMaximumPossibleScope(keys, dataModel) {
+        return this.service.getMaximumPossibleAmount(keys, dataModel.getMaxRecordsAmount());
+    }
+    static limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel) {
+        return this.service.limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel.getMaxRecordsAmount());
+    }
+    /**
+     * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
+     * @param configOptions
+     * @param chartsLength
+     */
+    static getElementsInGroupAmount(configOptions) {
+        const bars = this.getBarLikeChartsInGroupAmount(configOptions.charts, "bar");
+        const dots = configOptions.charts.some((chart) => chart.type === "dot") ? 1 : 0;
+        return Math.max(bars, dots);
+    }
+    static getBarLikeChartsInGroupAmount(charts, type) {
+        let barsAmount = 0;
+        charts.forEach((chart) => {
+            if (chart.type === type && chart.isSegmented)
+                barsAmount += 1; // в сегментированном баре все valueFields находятся внутри одного бара, поэтому бар всегда один.
+            else if (chart.type === type)
+                barsAmount += chart.data.valueFields.length;
+        });
+        return barsAmount;
+    }
+    static getScopedData(data, allowableKeys, dataOptions) {
+        const newData = {};
+        newData[dataOptions.dataSource] = this.getScopedChartData(data[dataOptions.dataSource], allowableKeys, dataOptions.keyField.name);
+        return newData;
+    }
+    static getScopedChartData(data, allowableKeys, keyFieldName) {
+        return data.filter((d) => allowableKeys.findIndex((key) => key === d[keyFieldName]) !== -1);
+    }
+    static getDataLimitByItemSize(elementsInGroupAmount, dataLength, axisLength, barOptions) {
+        let sumSize = dataLength *
+            (elementsInGroupAmount * barOptions.minBarWidth +
+                (elementsInGroupAmount - 1) * barOptions.barDistance +
+                barOptions.groupMinDistance);
+        while (dataLength !== 0 && axisLength < sumSize) {
+            dataLength--;
+            // find whole space for bars in group + distance between bars + group distance
+            sumSize =
+                dataLength *
+                    (elementsInGroupAmount * barOptions.minBarWidth +
+                        (elementsInGroupAmount - 1) * barOptions.barDistance +
+                        barOptions.groupMinDistance);
+        }
+        return dataLength;
+    }
 }
 DataManagerModel.service = new DataManagerModelService();
 DataManagerModel.polarMarginCalculator = new LegendPolarMarginCalculator();

package/lib/model/dataManagerModel/dataManagerModelService.d.ts

@@ -1,5 +1,5 @@
 import { DataScope } from "../model";
 export declare class DataManagerModelService {
-	getMaximumPossibleAmount(keys: string[], maxPossibleAmount: number): DataScope;
-	limitAllowableKeys(allowableKeys: string[], hidedRecordsAmount: number, globalRecordsMaxAmount: number): DataScope;
+    getMaximumPossibleAmount(keys: string[], maxPossibleAmount: number): DataScope;
+    limitAllowableKeys(allowableKeys: string[], hidedRecordsAmount: number, globalRecordsMaxAmount: number): DataScope;
 }

package/lib/model/dataManagerModel/dataManagerModelService.js

@@ -1,27 +1,28 @@
 export class DataManagerModelService {
-	getMaximumPossibleAmount(keys, maxPossibleAmount) {
-		if (maxPossibleAmount >= keys.length) {
-			return {
-				allowableKeys: keys,
-				hidedRecordsAmount: 0
-			};
-		} else {
-			return {
-				allowableKeys: keys.slice(0, maxPossibleAmount),
-				hidedRecordsAmount: keys.length - maxPossibleAmount
-			};
-		}
-	}
-	limitAllowableKeys(allowableKeys, hidedRecordsAmount, globalRecordsMaxAmount) {
-		if (allowableKeys.length <= globalRecordsMaxAmount) {
-			return {
-				allowableKeys,
-				hidedRecordsAmount
-			};
-		}
-		return {
-			allowableKeys: allowableKeys.slice(0, globalRecordsMaxAmount),
-			hidedRecordsAmount: hidedRecordsAmount + allowableKeys.length - globalRecordsMaxAmount
-		};
-	}
+    getMaximumPossibleAmount(keys, maxPossibleAmount) {
+        if (maxPossibleAmount >= keys.length) {
+            return {
+                allowableKeys: keys,
+                hidedRecordsAmount: 0
+            };
+        }
+        else {
+            return {
+                allowableKeys: keys.slice(0, maxPossibleAmount),
+                hidedRecordsAmount: keys.length - maxPossibleAmount
+            };
+        }
+    }
+    limitAllowableKeys(allowableKeys, hidedRecordsAmount, globalRecordsMaxAmount) {
+        if (allowableKeys.length <= globalRecordsMaxAmount) {
+            return {
+                allowableKeys,
+                hidedRecordsAmount
+            };
+        }
+        return {
+            allowableKeys: allowableKeys.slice(0, globalRecordsMaxAmount),
+            hidedRecordsAmount: hidedRecordsAmount + allowableKeys.length - globalRecordsMaxAmount
+        };
+    }
 }

package/lib/model/featuresModel/axisModel.d.ts

@@ -1,80 +1,29 @@
-import {
-	AxisPosition,
-	ChartOrientation,
-	MdtChartsDataSource,
-	NumberAxisOptions,
-	AxisLabelPosition,
-	MdtChartsTwoDimensionalOptions,
-	DiscreteAxisOptions,
-	NumberSecondaryAxisOptions,
-	AxisLabelFormatter
-} from "../../config/config";
+import { AxisPosition, ChartOrientation, MdtChartsDataSource, NumberAxisOptions, AxisLabelPosition, MdtChartsTwoDimensionalOptions, DiscreteAxisOptions, NumberSecondaryAxisOptions, AxisLabelFormatter } from "../../config/config";
 import { AxisModelOptions, Orient, ScaleValueModel, TickAmountPolicy } from "../model";
 import { AxisType } from "../modelBuilder";
 import { AxisLabelCanvas, TooltipSettings } from "../../designer/designerConfig";
 import { CanvasModel } from "../modelInstance/canvasModel/canvasModel";
 export interface LabelSize {
-	width: number;
-	height: number;
+    width: number;
+    height: number;
 }
 export declare const MINIMAL_VERTICAL_STEP_SIZE = 60;
 export declare const MINIMAL_HORIZONTAL_STEP_SIZE = 100;
 export declare const LABEL_ELEMENT_HEIGHT_PX = 17;
 export declare class AxisModel {
-	private static service;
-	static getKeyAxis(
-		options: MdtChartsTwoDimensionalOptions,
-		data: MdtChartsDataSource,
-		labelConfig: AxisLabelCanvas,
-		canvasModel: CanvasModel,
-		tooltipSettings: TooltipSettings,
-		getZeroCoordinate?: () => number
-	): AxisModelOptions;
-	static getMainValueAxis(
-		defaultFormatter: AxisLabelFormatter,
-		orient: ChartOrientation,
-		position: AxisPosition,
-		axisConfig: NumberAxisOptions,
-		labelConfig: AxisLabelCanvas,
-		canvasModel: CanvasModel,
-		scaleInfo: ScaleValueModel
-	): AxisModelOptions;
-	static getSecondaryValueAxis(
-		defaultFormatter: AxisLabelFormatter,
-		orient: ChartOrientation,
-		mainAxisPosition: AxisPosition,
-		axisConfig: NumberSecondaryAxisOptions,
-		labelConfig: AxisLabelCanvas,
-		canvasModel: CanvasModel,
-		scaleInfo: ScaleValueModel
-	): AxisModelOptions;
-	private static getValueAxis;
-	static getAxisLength(chartOrientation: ChartOrientation, canvasModel: CanvasModel): number;
-	static getAxisOrient(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition): Orient;
-	static getAxisTranslateX(
-		axisType: AxisType,
-		chartOrientation: ChartOrientation,
-		axisPosition: AxisPosition,
-		canvasModel: CanvasModel
-	): number;
-	static getAxisTranslateY(
-		axisType: AxisType,
-		chartOrientation: ChartOrientation,
-		axisPosition: AxisPosition,
-		canvasModel: CanvasModel
-	): number;
-	static getKeyAxisLabelPosition(
-		canvasModel: CanvasModel,
-		scopedDataLength: number,
-		axisConfig?: DiscreteAxisOptions
-	): AxisLabelPosition;
-	static getLabelSize(labelMaxWidth: number, labelTexts: string[]): LabelSize;
-	static getRoundValue(value: number): number;
-	static getTickAmountPolicy(
-		orient: ChartOrientation,
-		axisConfig: NumberAxisOptions | NumberSecondaryAxisOptions,
-		scaleInfo: ScaleValueModel
-	): TickAmountPolicy;
-	private static getKeyAxisTranslateModel;
-	private static getTickStep;
+    private static service;
+    static getKeyAxis(options: MdtChartsTwoDimensionalOptions, data: MdtChartsDataSource, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, tooltipSettings: TooltipSettings, getZeroCoordinate?: () => number): AxisModelOptions;
+    static getMainValueAxis(defaultFormatter: AxisLabelFormatter, orient: ChartOrientation, position: AxisPosition, axisConfig: NumberAxisOptions, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, scaleInfo: ScaleValueModel): AxisModelOptions;
+    static getSecondaryValueAxis(defaultFormatter: AxisLabelFormatter, orient: ChartOrientation, mainAxisPosition: AxisPosition, axisConfig: NumberSecondaryAxisOptions, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, scaleInfo: ScaleValueModel): AxisModelOptions;
+    private static getValueAxis;
+    static getAxisLength(chartOrientation: ChartOrientation, canvasModel: CanvasModel): number;
+    static getAxisOrient(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition): Orient;
+    static getAxisTranslateX(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition, canvasModel: CanvasModel): number;
+    static getAxisTranslateY(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition, canvasModel: CanvasModel): number;
+    static getKeyAxisLabelPosition(canvasModel: CanvasModel, scopedDataLength: number, axisConfig?: DiscreteAxisOptions): AxisLabelPosition;
+    static getLabelSize(labelMaxWidth: number, labelTexts: string[]): LabelSize;
+    static getRoundValue(value: number): number;
+    static getTickAmountPolicy(orient: ChartOrientation, axisConfig: NumberAxisOptions | NumberSecondaryAxisOptions, scaleInfo: ScaleValueModel): TickAmountPolicy;
+    private static getKeyAxisTranslateModel;
+    private static getTickStep;
 }