mdt-charts 1.12.1 → 1.12.5

package/lib/model/marginModel.js

@@ -3,7 +3,6 @@ import { DataManagerModel } from "./dataManagerModel/dataManagerModel";
 import { LegendModel } from "./featuresModel/legendModel/legendModel";
 import { AxisType } from "./modelBuilder";
 import { TwoDimensionalModel } from "./notations/twoDimensionalModel";
-import { PolarModel } from "./notations/polarModel";
 export const AXIS_HORIZONTAL_LABEL_PADDING = 15;
 export const AXIS_VERTICAL_LABEL_PADDING = 10;
 export class MarginModel {
@@ -24,21 +23,6 @@ export class MarginModel {
             this.recalcHorizontalMarginByAxisLabelWidth(labelSize, canvasModel, config.options.orientation, config.options.axis, showingFlag);
         }
     }
-    static recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, legendBlockModel, dataScope, options) {
-        const canvasModel = modelInstance.canvasModel;
-        let position = canvasModel.legendCanvas.getPosition();
-        if (position !== 'off') {
-            position = PolarModel.getLegendPositionByBlockSize(canvasModel); // reset position
-            this.clearMarginByLegendBlockPosition(canvasModel, legendBlockModel);
-            let allowableKeys = [...dataScope.allowableKeys];
-            if (dataScope.hidedRecordsAmount !== 0 && position === 'bottom')
-                allowableKeys.push('1'); // Если есть спрятанные записи, то в массив добавляется объект, чтобы выделить место в легенде для индикатора переполнения
-            const legendSize = LegendModel.getLegendSize(config.options.type, position, allowableKeys, designerConfig.canvas.legendBlock.maxWidth, config.canvas.size, legendBlockModel);
-            canvasModel.increaseMarginSide(position, legendSize + legendBlockModel.coordinate[position].margin[position]);
-            legendBlockModel.coordinate[position].size = legendSize;
-            options.legend.position = position;
-        }
-    }
     static recalcMarginByVerticalAxisLabel(modelInstance, config, designerConfig, dataScope) {
         if ((config.options.type === '2d' || config.options.type === 'interval') && config.options.orientation === 'vertical') {
             const axisLabelSize = AxisModel.getLabelSize(designerConfig.canvas.axisLabel.maxSize.main, dataScope.allowableKeys);
@@ -117,15 +101,6 @@ export class MarginModel {
         else
             canvasModel.increaseMarginSide(position, legendCoordinate[position].margin.top + legendCoordinate[position].margin.bottom);
     }
-    static clearMarginByLegendBlockPosition(canvasModel, legendBlockModel) {
-        const legendCoordinate = legendBlockModel.coordinate;
-        ['left', 'right', 'top', 'bottom'].forEach((position) => {
-            const decreaseByValue = legendCoordinate[position].size === 0
-                ? 0
-                : legendCoordinate[position].size + legendCoordinate[position].margin[position];
-            canvasModel.descreaseMarginSide(position, decreaseByValue);
-        });
-    }
     static recalcMarginByTitle(canvasModel, titleBlockModel) {
         canvasModel.increaseMarginSide("top", titleBlockModel.margin.top + titleBlockModel.size + titleBlockModel.margin.bottom);
     }

package/lib/model/model.d.ts

@@ -9,10 +9,10 @@ export declare type EmbeddedLabelTypeModel = "none" | "key" | "value";
 export declare type DataOptions = {
     [option: string]: any;
 };
-export interface Model {
+export interface Model<O = TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel> {
     blockCanvas: BlockCanvas;
     chartBlock: ChartBlockModel;
-    options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel;
+    options: O;
     otherComponents: OtherCommonComponents;
     dataSettings: DataSettings;
     transitions?: Transitions;
@@ -136,12 +136,24 @@ export interface BarChartSettings {
     maxBarWidth: number;
     minBarWidth: number;
 }
-export interface DonutChartSettings extends Omit<DonutOptionsCanvas, "aggregatorPad"> {
-    aggregator: DonutChartAggreagorModel;
+export interface DonutChartSettings extends Omit<DonutOptionsCanvas, "aggregatorPad" | "thickness"> {
+    aggregator: DonutAggregatorModel;
+    thickness: DonutThicknessOptions;
 }
-export interface DonutChartAggreagorModel {
+export interface DonutAggregatorModel {
     margin: number;
-    text: string;
+    content: DonutAggregatorContent;
+}
+export interface DonutAggregatorContent {
+    value: string | number;
+    title: string;
+}
+export declare type DonutThicknessUnit = "px" | "%";
+export interface DonutThicknessOptions {
+    min: number;
+    max: number;
+    value: number;
+    unit: DonutThicknessUnit;
 }
 interface ChartModel {
     tooltip: TooltipModel;

package/lib/model/modelBuilder.js

@@ -1,6 +1,6 @@
 import { MarginModel } from './marginModel';
 import { TwoDimensionalModel } from './notations/twoDimensionalModel';
-import { PolarModel } from './notations/polarModel';
+import { PolarModel } from './notations/polar/polarModel';
 import { DataManagerModel } from './dataManagerModel/dataManagerModel';
 import { IntervalModel } from './notations/intervalModel';
 import { OtherComponentsModel } from './featuresModel/otherComponents';
@@ -30,16 +30,16 @@ function getChartBlockModel(modelInstance) {
         margin: modelInstance.canvasModel.getMargin()
     };
 }
-function getOptions(config, designerConfig, modelInstance, dataScope, data) {
+function getOptions(config, designerConfig, modelInstance, data) {
     //TODO: migrate to polymorphism
     if (config.options.type === '2d') {
-        return TwoDimensionalModel.getOptions(config.options, designerConfig, dataScope, data, modelInstance);
+        return TwoDimensionalModel.getOptions(config.options, designerConfig, data, modelInstance);
     }
     else if (config.options.type === 'polar') {
-        return PolarModel.getOptions(config.options, data, designerConfig, modelInstance);
+        return PolarModel.getOptions(config.options, designerConfig, modelInstance);
     }
     else if (config.options.type === 'interval') {
-        return IntervalModel.getOptions(config, designerConfig, modelInstance.canvasModel.getMargin(), dataScope, data, modelInstance);
+        return IntervalModel.getOptions(config, designerConfig, modelInstance.canvasModel.getMargin(), modelInstance.dataModel.getScope(), data, modelInstance);
     }
 }
 function getDataSettings(dataScope, designerConfig) {
@@ -57,7 +57,7 @@ function getTransitions(designerConfig) {
     return designerConfig.transitions;
 }
 export function assembleModel(config, data, designerConfig) {
-    const modelInstance = ModelInstance.create(config);
+    const modelInstance = ModelInstance.create(config, data);
     if (!data || Object.keys(data).length === 0)
         return {
             blockCanvas: getBlockCanvas(config, modelInstance),
@@ -71,15 +71,14 @@ export function assembleModel(config, data, designerConfig) {
     MarginModel.initMargin(designerConfig, config, otherComponents, data, modelInstance);
     DataManagerModel.initDataScope(config, data, designerConfig, otherComponents.legendBlock, modelInstance);
     const preparedData = DataManagerModel.getPreparedData(data, modelInstance.dataModel.getAllowableKeys(), config);
+    modelInstance.dataModel.repository.initScopedFullSource(preparedData);
     if (config.options.type === '2d' && config.options.axis.key.visibility)
         MarginModel.recalcMarginByVerticalAxisLabel(modelInstance, config, designerConfig, modelInstance.dataModel.getScope());
     const blockCanvas = getBlockCanvas(config, modelInstance);
     const chartBlock = getChartBlockModel(modelInstance);
-    const options = getOptions(config, designerConfig, modelInstance, modelInstance.dataModel.getScope(), preparedData);
+    const options = getOptions(config, designerConfig, modelInstance, preparedData);
     const dataSettings = getDataSettings(modelInstance.dataModel.getScope(), designerConfig);
     const transitions = getTransitions(designerConfig);
-    // if (options.type === 'polar')
-    //     MarginModel.recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, otherComponents.legendBlock, modelInstance.dataModel.getScope(), options);
     modelInstance.canvasModel.roundMargin();
     return {
         blockCanvas,

package/lib/model/modelInstance/dataModel/dataModel.d.ts

@@ -0,0 +1,14 @@
+import { DataScope } from "../../model";
+import { DataRepositoryModel } from "./dataRepository";
+export declare const DEFAULT_MAX_RECORDS_AMOUNT = 50;
+export declare class DataModelInstance {
+    repository: DataRepositoryModel;
+    constructor();
+    private maxRecordsAmount;
+    private scope;
+    initMaxRecordsAmount(amount: number): void;
+    getMaxRecordsAmount(): number;
+    initScope(scope: DataScope): void;
+    getScope(): DataScope;
+    getAllowableKeys(): string[];
+}

package/lib/model/modelInstance/dataModel/dataModel.js

@@ -0,0 +1,26 @@
+import { DataRepositoryModel } from "./dataRepository";
+export const DEFAULT_MAX_RECORDS_AMOUNT = 50;
+export class DataModelInstance {
+    constructor() {
+        //TODO: create dataScopeModel. 
+        this.maxRecordsAmount = DEFAULT_MAX_RECORDS_AMOUNT;
+        this.repository = new DataRepositoryModel();
+    }
+    initMaxRecordsAmount(amount) {
+        if (typeof amount === "number" && amount > 0) {
+            this.maxRecordsAmount = amount;
+        }
+    }
+    getMaxRecordsAmount() {
+        return this.maxRecordsAmount;
+    }
+    initScope(scope) {
+        this.scope = scope;
+    }
+    getScope() {
+        return this.scope;
+    }
+    getAllowableKeys() {
+        return this.getScope().allowableKeys;
+    }
+}

package/lib/model/modelInstance/dataModel/dataRepository.d.ts

@@ -0,0 +1,12 @@
+import { MdtChartsDataSource } from "../../../config/config";
+export declare class DataRepositoryModel {
+    private rawFullSource;
+    private scopedFullSource;
+    private sourceName;
+    initSourceName(sourceName: string): void;
+    initRawFullSource(rawSource: MdtChartsDataSource): void;
+    getRawRows(): import("../../../config/config").MdtChartsDataRow[];
+    initScopedFullSource(scopedSource: MdtChartsDataSource): void;
+    getScopedFullSource(): MdtChartsDataSource;
+    getScopedRows(): import("../../../config/config").MdtChartsDataRow[];
+}

package/lib/model/modelInstance/dataModel/dataRepository.js

@@ -0,0 +1,20 @@
+export class DataRepositoryModel {
+    initSourceName(sourceName) {
+        this.sourceName = sourceName;
+    }
+    initRawFullSource(rawSource) {
+        this.rawFullSource = rawSource;
+    }
+    getRawRows() {
+        return this.rawFullSource[this.sourceName];
+    }
+    initScopedFullSource(scopedSource) {
+        this.scopedFullSource = scopedSource;
+    }
+    getScopedFullSource() {
+        return this.scopedFullSource;
+    }
+    getScopedRows() {
+        return this.scopedFullSource[this.sourceName];
+    }
+}

package/lib/model/modelInstance/modelInstance.d.ts

@@ -1,8 +1,8 @@
-import { MdtChartsConfig } from "../../main";
+import { MdtChartsConfig, MdtChartsDataSource } from "../../config/config";
 import { CanvasModel } from "./canvasModel/canvasModel";
-import { DataModelInstance } from "./dataModel";
+import { DataModelInstance } from "./dataModel/dataModel";
 export declare class ModelInstance {
-    static create(config: MdtChartsConfig): ModelInstance;
+    static create(config: MdtChartsConfig, data: MdtChartsDataSource): ModelInstance;
     private static initInitialParams;
     canvasModel: CanvasModel;
     dataModel: DataModelInstance;

package/lib/model/modelInstance/modelInstance.js

@@ -1,17 +1,19 @@
 import { CanvasModel } from "./canvasModel/canvasModel";
-import { DataModelInstance } from "./dataModel";
+import { DataModelInstance } from "./dataModel/dataModel";
 export class ModelInstance {
     constructor() {
         this.canvasModel = new CanvasModel();
         this.dataModel = new DataModelInstance();
     }
-    static create(config) {
+    static create(config, data) {
         const modelInstance = new ModelInstance();
-        this.initInitialParams(modelInstance, config);
+        this.initInitialParams(modelInstance, config, data);
         return modelInstance;
     }
-    static initInitialParams(modelInstance, config) {
+    static initInitialParams(modelInstance, config, data) {
         modelInstance.canvasModel.initBlockSize(config.canvas.size);
         modelInstance.dataModel.initMaxRecordsAmount(config.options.data.maxRecordsAmount);
+        modelInstance.dataModel.repository.initSourceName(config.options.data.dataSource);
+        modelInstance.dataModel.repository.initRawFullSource(data);
     }
 }

package/lib/model/notations/intervalModel.d.ts

@@ -1,9 +1,9 @@
-import { MdtChartsConfig, MdtChartsDataSource, IntervalOptions } from "../../config/config";
+import { MdtChartsConfig, MdtChartsDataSource, MdtChartsIntervalOptions } from "../../config/config";
 import { DesignerConfig } from "../../designer/designerConfig";
 import { AdditionalElementsOptions, BlockMargin, DataScope, IntervalOptionsModel } from "../model";
 import { ModelInstance } from "../modelInstance/modelInstance";
 export declare class IntervalModel {
     static getOptions(config: MdtChartsConfig, designerConfig: DesignerConfig, margin: BlockMargin, dataScope: DataScope, data: MdtChartsDataSource, modelInstance: ModelInstance): IntervalOptionsModel;
-    static getAdditionalElements(options: IntervalOptions): AdditionalElementsOptions;
+    static getAdditionalElements(options: MdtChartsIntervalOptions): AdditionalElementsOptions;
     private static getChartsModel;
 }

package/lib/model/notations/polar/donut/donutAggregatorService.d.ts

@@ -0,0 +1,12 @@
+import { MdtChartsDataRow, MdtChartsDonutAggregator } from "../../../../config/config";
+import { DonutAggregatorContent } from "../../../model";
+export declare const AGGREGATOR_DEFAULT_TITLE = "\u0421\u0443\u043C\u043C\u0430";
+export interface AggregatorServiceDataOptions {
+    rows: MdtChartsDataRow[];
+    valueFieldName: string;
+}
+export declare class DonutAggregatorService {
+    getContent(aggregatorOptions: MdtChartsDonutAggregator, dataOptions: AggregatorServiceDataOptions): DonutAggregatorContent;
+    private doesValueExist;
+    private generateDefaultContent;
+}

package/lib/model/notations/polar/donut/donutAggregatorService.js

@@ -0,0 +1,25 @@
+export const AGGREGATOR_DEFAULT_TITLE = "Сумма";
+export class DonutAggregatorService {
+    getContent(aggregatorOptions, dataOptions) {
+        if (!(aggregatorOptions === null || aggregatorOptions === void 0 ? void 0 : aggregatorOptions.content) || !dataOptions.rows)
+            return this.generateDefaultContent(dataOptions);
+        const content = aggregatorOptions.content({ data: dataOptions.rows });
+        if (this.doesValueExist(content.value) && content.title)
+            return content;
+        if (!content.title && this.doesValueExist(content.value))
+            return {
+                value: content.value,
+                title: AGGREGATOR_DEFAULT_TITLE
+            };
+        return this.generateDefaultContent(dataOptions);
+    }
+    doesValueExist(content) {
+        return content != null;
+    }
+    generateDefaultContent(dataOptions) {
+        return {
+            title: AGGREGATOR_DEFAULT_TITLE,
+            value: dataOptions.rows ? dataOptions.rows.reduce((acc, row) => acc + row[dataOptions.valueFieldName], 0) : 0
+        };
+    }
+}

package/lib/model/notations/polar/donut/donutModel.d.ts

@@ -0,0 +1,10 @@
+import { MdtChartsDataRow, PolarChart } from "../../../../config/config";
+import { DonutOptionsCanvas } from "../../../../designer/designerConfig";
+import { DonutChartSettings } from "../../../model";
+export declare class DonutModel {
+    private thicknessService;
+    private aggregatorService;
+    getSettings(settingsFromConfig: DonutOptionsCanvas, chartOptions: PolarChart, rawDataRows: MdtChartsDataRow[]): DonutChartSettings;
+    private getThicknessOptions;
+    private getAggregatorOptions;
+}

package/lib/model/notations/polar/donut/donutModel.js

@@ -0,0 +1,32 @@
+import { DonutAggregatorService } from "./donutAggregatorService";
+import { DonutThicknessService } from "./donutThicknessService";
+export class DonutModel {
+    constructor() {
+        this.thicknessService = new DonutThicknessService();
+        this.aggregatorService = new DonutAggregatorService();
+    }
+    getSettings(settingsFromConfig, chartOptions, rawDataRows) {
+        return {
+            padAngle: settingsFromConfig.padAngle,
+            thickness: this.getThicknessOptions(settingsFromConfig.thickness),
+            aggregator: this.getAggregatorOptions(settingsFromConfig, chartOptions, rawDataRows)
+        };
+    }
+    getThicknessOptions(settingsFromConfig) {
+        return {
+            unit: this.thicknessService.getUnit(settingsFromConfig),
+            max: this.thicknessService.valueToNumber(settingsFromConfig.max),
+            min: this.thicknessService.valueToNumber(settingsFromConfig.min),
+            value: this.thicknessService.valueToNumber(settingsFromConfig.value),
+        };
+    }
+    getAggregatorOptions(settingsFromConfig, chartOptions, rawDataRows) {
+        return {
+            margin: settingsFromConfig.aggregatorPad,
+            content: this.aggregatorService.getContent(chartOptions.aggregator, {
+                rows: rawDataRows,
+                valueFieldName: chartOptions.data.valueField.name
+            })
+        };
+    }
+}

package/lib/model/notations/polar/donut/donutThicknessService.d.ts

@@ -0,0 +1,9 @@
+import { MdtChartsDonutThicknessOptions } from "../../../../designer/designerConfig";
+import { DonutThicknessUnit } from "../../../model";
+export declare class DonutThicknessService {
+    private defaultUnit;
+    getUnit(settingsFromConfig: MdtChartsDonutThicknessOptions): DonutThicknessUnit;
+    valueToNumber(value: string | number): number;
+    private getUnitByValue;
+    private getLastUnitFromString;
+}

package/lib/model/notations/polar/donut/donutThicknessService.js

@@ -0,0 +1,30 @@
+export class DonutThicknessService {
+    constructor() {
+        this.defaultUnit = "px";
+    }
+    getUnit(settingsFromConfig) {
+        if (settingsFromConfig.value)
+            return this.getUnitByValue(settingsFromConfig.value);
+        const minUnit = this.getUnitByValue(settingsFromConfig.min);
+        const maxUnit = this.getUnitByValue(settingsFromConfig.max);
+        return minUnit === maxUnit ? minUnit : this.defaultUnit;
+    }
+    valueToNumber(value) {
+        if (typeof value === "number")
+            return value;
+        return parseInt(value);
+    }
+    getUnitByValue(value) {
+        if (typeof value !== "string")
+            return this.defaultUnit;
+        return this.getLastUnitFromString(value);
+    }
+    getLastUnitFromString(value) {
+        let resultUnit = this.defaultUnit;
+        ["%", "px"].forEach(unit => {
+            if (value.endsWith(unit))
+                resultUnit = unit;
+        });
+        return resultUnit;
+    }
+}

package/lib/model/notations/polar/polarModel.d.ts

@@ -0,0 +1,15 @@
+import { MdtChartsPolarOptions } from "../../../config/config";
+import { DesignerConfig } from "../../../designer/designerConfig";
+import { PolarOptionsModel, LegendCoordinate } from "../../model";
+import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
+import { ModelInstance } from "../../modelInstance/modelInstance";
+export declare const MIN_DONUT_BLOCK_SIZE = 120;
+export declare class PolarModel {
+    private static donutModel;
+    static getOptions(options: MdtChartsPolarOptions, designerConfig: DesignerConfig, modelInstance: ModelInstance): PolarOptionsModel;
+    static getLegendPositionByBlockSize(canvasModel: CanvasModel): "bottom" | "right";
+    static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth: number, legendWidth: number, legendCoordinate: LegendCoordinate): boolean;
+    static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight: number, legendCoordinate: LegendCoordinate): boolean;
+    private static getDonutSettings;
+    private static getChartsModel;
+}

package/lib/model/notations/polar/polarModel.js

@@ -0,0 +1,53 @@
+import { ChartStyleModelService } from "../../chartStyleModel/chartStyleModel";
+import { DonutModel } from "./donut/donutModel";
+export const MIN_DONUT_BLOCK_SIZE = 120;
+export class PolarModel {
+    static getOptions(options, designerConfig, modelInstance) {
+        return {
+            type: options.type,
+            selectable: !!options.selectable,
+            title: options.title,
+            data: Object.assign({}, options.data),
+            charts: this.getChartsModel(options.chart, modelInstance.dataModel.repository.getScopedRows().length, designerConfig.chartStyle),
+            legend: modelInstance.canvasModel.legendCanvas.getModel(),
+            tooltip: options.tooltip,
+            chartCanvas: this.getDonutSettings(designerConfig.canvas.chartOptions.donut, options.chart, modelInstance.dataModel.repository.getRawRows())
+        };
+    }
+    //TODO: type for returned value
+    static getLegendPositionByBlockSize(canvasModel) {
+        const widthCoefficientWhenLegendShouldInBottom = 1.5;
+        const avgLegendWidth = 100;
+        const blockWidth = canvasModel.getBlockSize().width;
+        const blockHeight = canvasModel.getBlockSize().height;
+        return canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE + avgLegendWidth
+            && blockWidth * widthCoefficientWhenLegendShouldInBottom < blockHeight
+            ? 'bottom'
+            : 'right';
+    }
+    static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth, legendWidth, legendCoordinate) {
+        const rightLegendMargin = legendCoordinate.right.margin;
+        return chartBlockWidth - legendWidth - rightLegendMargin.left - rightLegendMargin.right >= MIN_DONUT_BLOCK_SIZE;
+    }
+    static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight, legendCoordinate) {
+        const minHeightForLegend = 30;
+        const bottomLegendMargin = legendCoordinate.bottom.margin;
+        const heightForLegend = chartBlockHeight - bottomLegendMargin.bottom - bottomLegendMargin.top - MIN_DONUT_BLOCK_SIZE;
+        return heightForLegend >= minHeightForLegend;
+    }
+    static getDonutSettings(settings, chartOptions, dataRows) {
+        return this.donutModel.getSettings(settings, chartOptions, dataRows);
+    }
+    static getChartsModel(chart, dataLength, chartStyleConfig) {
+        const chartsModel = [];
+        chartsModel.push({
+            type: chart.type,
+            data: Object.assign({}, chart.data),
+            tooltip: chart.tooltip,
+            cssClasses: ChartStyleModelService.getCssClasses(0),
+            style: ChartStyleModelService.getChartStyle(dataLength, chartStyleConfig)
+        });
+        return chartsModel;
+    }
+}
+PolarModel.donutModel = new DonutModel();

package/lib/model/notations/twoDimensionalModel.d.ts

@@ -1,21 +1,21 @@
-import { ChartOrientation, MdtChartsDataSource, TwoDimensionalChart, MdtChartsTwoDimensionalOptions } from "../../config/config";
+import { ChartOrientation, MdtChartsDataSource, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions } from "../../config/config";
 import { BarOptionsCanvas, DesignerConfig } from "../../designer/designerConfig";
-import { DataScope, TwoDimensionalOptionsModel, TwoDimChartElementsSettings } from "../model";
+import { TwoDimensionalOptionsModel, TwoDimChartElementsSettings } from "../model";
 import { ModelInstance } from "../modelInstance/modelInstance";
 export declare class TwoDimensionalModel {
-    static getOptions(options: MdtChartsTwoDimensionalOptions, designerConfig: DesignerConfig, dataScope: DataScope, data: MdtChartsDataSource, modelInstance: ModelInstance): TwoDimensionalOptionsModel;
-    static getChartsEmbeddedLabelsFlag(charts: TwoDimensionalChart[], chartOrientation: ChartOrientation): boolean;
+    static getOptions(options: MdtChartsTwoDimensionalOptions, designerConfig: DesignerConfig, data: MdtChartsDataSource, modelInstance: ModelInstance): TwoDimensionalOptionsModel;
+    static getChartsEmbeddedLabelsFlag(charts: MdtChartsTwoDimensionalChart[], chartOrientation: ChartOrientation): boolean;
     /**
      * Сортирует список чартов в порядке: area - bar - line.
      * Используется для того, чтобы при рендере графики с наибольшей площадью (area) не перекрывали графики с меньшей площадью (bar, line).
      * @param charts Чарты из конфига
      */
-    static sortCharts(charts: TwoDimensionalChart[]): void;
+    static sortCharts(charts: MdtChartsTwoDimensionalChart[]): void;
     static getChartsSettings(barSettings: BarOptionsCanvas): TwoDimChartElementsSettings;
     private static getChartsModel;
     private static findChartsWithEmbeddedKeyLabels;
     private static getEmbeddedLabelType;
     private static getAdditionalElements;
     private static getChartsByType;
-    static getChartsValueFieldsAmount(charts: TwoDimensionalChart[]): number[];
+    static getChartsValueFieldsAmount(charts: MdtChartsTwoDimensionalChart[]): number[];
 }

package/lib/model/notations/twoDimensionalModel.js

@@ -1,21 +1,27 @@
+import { Scale } from "../../engine/features/scale/scale";
 import { ChartStyleModelService } from "../chartStyleModel/chartStyleModel";
 import { TwoDimensionalChartStyleModel } from "../chartStyleModel/TwoDimensionalChartStyleModel";
 import { AxisModel } from "../featuresModel/axisModel";
 import { ScaleModel } from "../featuresModel/scaleModel";
 export class TwoDimensionalModel {
-    static getOptions(options, designerConfig, dataScope, data, modelInstance) {
+    static getOptions(options, designerConfig, data, modelInstance) {
         const canvasModel = modelInstance.canvasModel;
+        const scaleKey = ScaleModel.getScaleKey(modelInstance.dataModel.getAllowableKeys(), options.orientation, canvasModel, options.charts, this.getChartsByType(options.charts, 'bar'));
+        const scaleValue = ScaleModel.getScaleLinear(options, data, canvasModel);
+        const chartSettings = this.getChartsSettings(designerConfig.canvas.chartOptions.bar);
+        //TODO: rm import from engine
+        const scaleValueFn = Scale.getScaleValue(scaleValue);
         return {
             legend: canvasModel.legendCanvas.getModel(),
             title: options.title,
             selectable: !!options.selectable,
             orient: options.orientation,
             scale: {
-                key: ScaleModel.getScaleKey(dataScope.allowableKeys, options.orientation, canvasModel, options.charts, this.getChartsByType(options.charts, 'bar')),
-                value: ScaleModel.getScaleLinear(options, data, canvasModel)
+                key: scaleKey,
+                value: scaleValue
             },
             axis: {
-                key: AxisModel.getKeyAxis(options, data, designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip),
+                key: AxisModel.getKeyAxis(options, data, designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip, () => scaleValueFn(0)),
                 value: AxisModel.getValueAxis(options.orientation, options.axis.value, designerConfig.canvas.axisLabel, canvasModel)
             },
             type: options.type,
@@ -23,7 +29,7 @@ export class TwoDimensionalModel {
             charts: this.getChartsModel(options.charts, options.orientation, designerConfig.chartStyle),
             additionalElements: this.getAdditionalElements(options),
             tooltip: options.tooltip,
-            chartSettings: this.getChartsSettings(designerConfig.canvas.chartOptions.bar)
+            chartSettings
         };
     }
     static getChartsEmbeddedLabelsFlag(charts, chartOrientation) {

package/lib/style/charts-main.css

@@ -1,5 +1,3 @@
-@import url('https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap');
-
 .wrapper {
     margin: 0 auto;
     position: relative;
@@ -60,6 +58,7 @@
 .legend-item {
     cursor: default;
     transition: opacity 0.1s;
+    line-height: 1;
     /* will-change: opacity;      */
 }
 .legend-block-column .legend-item:not(:first-of-type) {
@@ -202,12 +201,15 @@
     line-height: 1;
 }
 .aggregator-value {
-    margin-top: 20px;
+    margin-top: 0.5em;
     pointer-events: auto;
 }
 .aggregator-name {
-    margin-top: 10px;
+    margin-top: 0.5em;
     pointer-events: auto;
+    max-width: 90%;
+    overflow: hidden;
+    text-overflow: ellipsis;
 }
 
 /* Grid */

package/lib/style/charts-main.less

@@ -1,5 +1,3 @@
-@import url('https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap');
-
 .wrapper {
     margin: 0 auto;
     position: relative;
@@ -60,6 +58,7 @@
 .legend-item {
     cursor: default;
     transition: opacity 0.1s;
+    line-height: 1;
     /* will-change: opacity;      */
 }
 .legend-block-column .legend-item:not(:first-of-type) {
@@ -202,12 +201,15 @@
     line-height: 1;
 }
 .aggregator-value {
-    margin-top: 20px;
+    margin-top: 0.5em;
     pointer-events: auto;
 }
 .aggregator-name {
-    margin-top: 10px;
+    margin-top: 0.5em;
     pointer-events: auto;
+    max-width: 90%;
+    overflow: hidden;
+    text-overflow: ellipsis;
 }
 
 /* Grid */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdt-charts",
-  "version": "1.12.1",
+  "version": "1.12.5",
   "description": "",
   "main": "lib/main.js",
   "scripts": {