mdt-charts 1.10.3 → 1.12.1

package/lib/engine/polarNotation/donut/donut.js

@@ -11,6 +11,7 @@ export class Donut {
         const arcGenerator = DonutHelper.getArcGenerator(outerRadius, innerRadius);
         const pieGenerator = DonutHelper.getPieGenerator(chart.data.valueField.name, settings.padAngle);
         const translateAttr = DonutHelper.getTranslate(margin, blockSize);
+        Aggregator.render(block, data, chart.data.valueField, innerRadius, translateAttr, thickness, settings.aggregator);
         const donutBlock = block.getSvg()
             .append('g')
             .attr('class', this.donutBlockClass)
@@ -19,7 +20,6 @@ export class Donut {
             .attr('transform', `translate(${translateAttr.x}, ${translateAttr.y})`);
         this.renderNewArcItems(arcGenerator, pieGenerator, donutBlock, data, chart);
         this.renderClonesG(donutBlock);
-        Aggregator.render(block, data, chart.data.valueField, innerRadius, translateAttr, thickness, settings.aggregatorPad);
     }
     static update(block, data, margin, chart, blockSize, donutSettings, keyField) {
         const outerRadius = DonutHelper.getOuterRadius(margin, blockSize);

package/lib/engine/polarNotation/extenders/polarRecordOverflowAlert.d.ts

@@ -0,0 +1,15 @@
+import { LegendPosition } from "../../../model/model";
+import { Block } from "../../block/block";
+interface PolarRecordOverflowAlertOptions {
+    hidedRecordsAmount: number;
+    legendPosition: LegendPosition;
+}
+declare class PolarRecordOverflowAlertClass {
+    private readonly text;
+    render(block: Block, options: PolarRecordOverflowAlertOptions): void;
+    update(block: Block, options: PolarRecordOverflowAlertOptions): void;
+    private buildCoreOptions;
+    private getPositionAttrs;
+}
+export declare const PolarRecordOverflowAlert: PolarRecordOverflowAlertClass;
+export {};

package/lib/engine/polarNotation/extenders/polarRecordOverflowAlert.js

@@ -0,0 +1,40 @@
+import { RecordOverflowAlertCore } from "../../features/recordOverflowAlert/recordOverflowAlertCore";
+class PolarRecordOverflowAlertClass {
+    constructor() {
+        this.text = {
+            one: 'категория',
+            twoToFour: 'категории',
+            tenToTwenty: 'категорий',
+            other: 'категорий'
+        };
+    }
+    render(block, options) {
+        RecordOverflowAlertCore.render(block, this.buildCoreOptions(options));
+    }
+    update(block, options) {
+        RecordOverflowAlertCore.update(block, this.buildCoreOptions(options));
+    }
+    buildCoreOptions(options) {
+        return {
+            hidedRecordsAmount: options.hidedRecordsAmount,
+            text: this.text,
+            positionAttrs: this.getPositionAttrs(options)
+        };
+    }
+    getPositionAttrs(options) {
+        const position = options.legendPosition === 'off' ? 'bottom' : options.legendPosition;
+        if (position === 'right') {
+            return {
+                bottom: '0',
+                right: '0'
+            };
+        }
+        if (position === 'bottom') {
+            return {
+                bottom: '0',
+                left: '0'
+            };
+        }
+    }
+}
+export const PolarRecordOverflowAlert = new PolarRecordOverflowAlertClass();

package/lib/engine/polarNotation/polarManager.js

@@ -1,26 +1,28 @@
 import { Legend } from "../features/legend/legend";
-import { RecordOverflowAlert } from "../features/recordOverflowAlert/recordOverflowAlert";
 import { Title } from "../features/title/title";
 import { ElementHighlighter } from "../elementHighlighter/elementHighlighter";
 import { Tooltip } from "../features/tolltip/tooltip";
 import { Aggregator } from "../features/aggregator/aggregator";
 import { Donut } from "./donut/donut";
+import { PolarRecordOverflowAlert } from "./extenders/polarRecordOverflowAlert";
 export class PolarManager {
     static render(engine, model) {
         const options = model.options;
         engine.block.renderSvg(model.blockCanvas.size);
-        this.renderCharts(engine.block, options.charts, engine.data, options.data.dataSource, model.chartBlock.margin, model.blockCanvas.size, model.chartSettings.donut);
+        this.renderCharts(engine.block, options.charts, engine.data, options.data.dataSource, model.chartBlock.margin, model.blockCanvas.size, options.chartCanvas);
         Title.render(engine.block, options.title, model.otherComponents.titleBlock, model.blockCanvas.size);
         Legend.render(engine.block, engine.data, options, model);
-        ``;
         Tooltip.render(engine.block, model, engine.data, model.otherComponents.tooltipBlock);
-        engine.block.filterEventManager.setListenerPolar(model.chartBlock.margin, model.blockCanvas.size, options, model.chartSettings.donut);
-        if (model.dataSettings.scope.hidedRecordsAmount !== 0 && model.options.legend.position !== 'off')
-            RecordOverflowAlert.render(engine.block, model.dataSettings.scope.hidedRecordsAmount, model.options.legend.position);
+        engine.block.filterEventManager.setListenerPolar(model.chartBlock.margin, model.blockCanvas.size, options);
+        if (model.dataSettings.scope.hidedRecordsAmount !== 0)
+            PolarRecordOverflowAlert.render(engine.block, {
+                hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
+                legendPosition: model.options.legend.position
+            });
         engine.block.getSvg()
             .on('click', (e) => {
             if (e.target === engine.block.getSvg().node())
-                engine.block.filterEventManager.clearKeysForPolar(model.chartBlock.margin, model.blockCanvas.size, options, model.chartSettings.donut);
+                engine.block.filterEventManager.clearKeysForPolar(model.chartBlock.margin, model.blockCanvas.size, options);
         });
     }
     static update(block, model, data) {
@@ -32,15 +34,17 @@ export class PolarManager {
         ElementHighlighter.toggleActivityStyle(Donut.getAllArcGroups(block), true);
         Tooltip.hide(block);
         const options = model.options;
-        Donut.update(block, data[options.data.dataSource], model.chartBlock.margin, options.charts[0], model.blockCanvas.size, model.chartSettings.donut, options.data.keyField.name)
+        Donut.update(block, data[options.data.dataSource], model.chartBlock.margin, options.charts[0], model.blockCanvas.size, options.chartCanvas, options.data.keyField.name)
             .then(() => {
             Tooltip.render(block, model, data, model.otherComponents.tooltipBlock);
-            block.filterEventManager.setListenerPolar(model.chartBlock.margin, model.blockCanvas.size, options, model.chartSettings.donut);
+            block.filterEventManager.setListenerPolar(model.chartBlock.margin, model.blockCanvas.size, options);
         });
-        Aggregator.update(block, data[options.data.dataSource], options.charts[0].data.valueField, model.chartSettings.donut.aggregatorPad);
+        Aggregator.update(block, data[options.data.dataSource], options.charts[0].data.valueField, options.chartCanvas.aggregator);
         Legend.update(block, data, model);
-        if (model.options.legend.position !== 'off')
-            RecordOverflowAlert.update(block, model.dataSettings.scope.hidedRecordsAmount, model.options.legend.position);
+        PolarRecordOverflowAlert.update(block, {
+            hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
+            legendPosition: model.options.legend.position
+        });
     }
     static updateColors(block, model) {
         Legend.updateColors(block, model.options);

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

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

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

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

package/lib/engine/twoDimensionalNotation/twoDimensionalManager.js

@@ -3,7 +3,6 @@ import { Axis } from "../features/axis/axis";
 import { EmbeddedLabels } from "../features/embeddedLabels/embeddedLabels";
 import { GridLine } from "../features/gridLine/gridLine";
 import { Legend } from "../features/legend/legend";
-import { RecordOverflowAlert } from "../features/recordOverflowAlert/recordOverflowAlert";
 import { Scale } from "../features/scale/scale";
 import { TipBox } from "../features/tipBox/tipBox";
 import { Title } from "../features/title/title";
@@ -12,23 +11,27 @@ import { Helper } from "../helpers/helper";
 import { Area } from "./area/area";
 import { Bar } from "./bar/bar";
 import { BarHelper } from "./bar/barHelper";
+import { TwoDimRecordOverflowAlert } from "./extenders/twoDimRecordOverflowAlert";
 import { Line } from "./line/line";
 export class TwoDimensionalManager {
     static render(engine, model) {
         const options = model.options;
-        const scales = Scale.getScales(options.scale.key, options.scale.value, model.chartSettings.bar);
+        const scales = Scale.getScales(options.scale.key, options.scale.value, options.chartSettings.bar);
         engine.block.scales = scales;
         engine.block.renderSvg(model.blockCanvas.size);
         Axis.render(engine.block, scales, options.scale, options.axis, model.blockCanvas.size);
         GridLine.render(engine.block, options.additionalElements.gridLine.flag, options.axis, model.blockCanvas.size, model.chartBlock.margin, options.scale.key);
-        this.renderCharts(engine.block, options.charts, scales, engine.data, options.data, model.chartBlock.margin, options.axis.key.orient, model.chartSettings.bar, model.blockCanvas.size);
+        this.renderCharts(engine.block, options.charts, scales, engine.data, options.data, model.chartBlock.margin, options.axis.key.orient, options.chartSettings.bar, model.blockCanvas.size);
         engine.block.filterEventManager.registerEventFor2D(scales.key, model.chartBlock.margin, model.blockCanvas.size, options);
         engine.block.filterEventManager.event2DUpdate(options);
         Title.render(engine.block, options.title, model.otherComponents.titleBlock, model.blockCanvas.size);
         Legend.render(engine.block, engine.data, options, model);
         Tooltip.render(engine.block, model, engine.data, model.otherComponents.tooltipBlock, scales);
         if (model.dataSettings.scope.hidedRecordsAmount !== 0)
-            RecordOverflowAlert.render(engine.block, model.dataSettings.scope.hidedRecordsAmount, 'top', options.orient);
+            TwoDimRecordOverflowAlert.render(engine.block, {
+                hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
+                chartOrientation: options.orient
+            });
         engine.block.getSvg()
             .on('click', (e) => {
             if (e.target === engine.block.getSvg().node())
@@ -42,19 +45,22 @@ export class TwoDimensionalManager {
         Tooltip.hide(block);
         const options = model.options;
         ElementHighlighter.remove2DChartsFullHighlighting(block, options.charts);
-        const scales = Scale.getScales(options.scale.key, options.scale.value, model.chartSettings.bar);
+        const scales = Scale.getScales(options.scale.key, options.scale.value, options.chartSettings.bar);
         const keyDomainEquality = Helper.checkDomainsEquality(block.scales.key.domain(), scales.key.domain());
         block.scales = scales;
         Axis.update(block, scales, options.scale, options.axis, model.blockCanvas.size, keyDomainEquality);
         GridLine.update(block, options.additionalElements.gridLine.flag, options.axis, model.blockCanvas.size, model.chartBlock.margin, options.scale.key);
-        const promises = this.updateCharts(block, options.charts, scales, data, model.options.data, model.chartBlock.margin, options.axis.key.orient, model.blockCanvas.size, model.chartSettings.bar);
+        const promises = this.updateCharts(block, options.charts, scales, data, model.options.data, model.chartBlock.margin, options.axis.key.orient, model.blockCanvas.size, options.chartSettings.bar);
         Promise.all(promises)
             .then(() => {
             block.filterEventManager.event2DUpdate(options);
             block.filterEventManager.registerEventFor2D(scales.key, model.chartBlock.margin, model.blockCanvas.size, options);
             Tooltip.render(block, model, data, model.otherComponents.tooltipBlock, scales);
         });
-        RecordOverflowAlert.update(block, model.dataSettings.scope.hidedRecordsAmount, 'top', options.orient);
+        TwoDimRecordOverflowAlert.update(block, {
+            hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
+            chartOrientation: options.orient
+        });
     }
     static updateColors(block, model) {
         Legend.updateColors(block, model.options);

package/lib/model/chartStyleModel/TwoDimensionalChartStyleModel.d.ts

@@ -0,0 +1,19 @@
+import { TwoDimensionalChart, TwoDimensionalChartType } from "../../config/config";
+import { ChartStyleConfig } from "../../designer/designerConfig";
+import { ChartStyle } from "../model";
+export declare class TwoDimensionalChartStyleModel {
+    private charts;
+    private chartStyleConfig;
+    private service;
+    constructor(charts: TwoDimensionalChart[], chartStyleConfig: ChartStyleConfig);
+    getChartStyle(chart: TwoDimensionalChart, chartIndex: number): ChartStyle;
+    private getChartsValueFieldsAmounts;
+}
+export declare class TwoDimensionalChartStyleService {
+    getChartColors(chart: TwoDimensionalChart, styleConfig: ChartStyleConfig, chartsFieldsAmounts: number[], chartIndex: number): string[];
+    getChartOpacity(chartsLength: number, chartType: TwoDimensionalChartType, chartsValueFieldAmount: number, isChartSegmented: boolean): number;
+    private generateNewChartColors;
+    private isMoreThanOneValueFieldOnCanvas;
+    private makeColorsBrighter;
+    private getStartIndex;
+}

package/lib/model/chartStyleModel/TwoDimensionalChartStyleModel.js

@@ -0,0 +1,61 @@
+import * as chroma from "chroma-js";
+import { ModelHelper } from "../modelHelper";
+import { ChartStyleModelService } from "./chartStyleModel";
+export class TwoDimensionalChartStyleModel {
+    constructor(charts, chartStyleConfig) {
+        this.charts = charts;
+        this.chartStyleConfig = chartStyleConfig;
+        this.service = new TwoDimensionalChartStyleService();
+    }
+    getChartStyle(chart, chartIndex) {
+        const fieldsAmounts = this.getChartsValueFieldsAmounts();
+        return {
+            elementColors: this.service.getChartColors(chart, this.chartStyleConfig, fieldsAmounts, chartIndex),
+            opacity: this.service.getChartOpacity(this.charts.length, chart.type, fieldsAmounts[chartIndex], chart.isSegmented)
+        };
+    }
+    getChartsValueFieldsAmounts() {
+        return this.charts.map(chart => chart.data.valueFields.length);
+    }
+}
+export class TwoDimensionalChartStyleService {
+    getChartColors(chart, styleConfig, chartsFieldsAmounts, chartIndex) {
+        const generatedColors = this.generateNewChartColors(chart.type, styleConfig, chartsFieldsAmounts, chartIndex);
+        chart.data.valueFields.forEach((field, fieldIndex) => {
+            if (field.color)
+                generatedColors[fieldIndex] = field.color;
+        });
+        return generatedColors;
+    }
+    getChartOpacity(chartsLength, chartType, chartsValueFieldAmount, isChartSegmented) {
+        if (chartType === 'area' && this.isMoreThanOneValueFieldOnCanvas(chartsLength, chartsValueFieldAmount) && !isChartSegmented)
+            return 0.5; // combined area with other charts has 0.5 opacity
+        return 1;
+    }
+    generateNewChartColors(chartType, styleConfig, chartsFieldsAmounts, chartIndex) {
+        const startIndex = this.getStartIndex(chartIndex, chartsFieldsAmounts);
+        const baseColors = ChartStyleModelService.checkAndGet(styleConfig.baseColors);
+        const palette = ChartStyleModelService.getColorSet(baseColors, ModelHelper.getSum(chartsFieldsAmounts));
+        const elementsAmount = chartsFieldsAmounts[chartIndex];
+        const selectedColors = palette.slice(startIndex, startIndex + elementsAmount);
+        if (chartType !== 'line')
+            return selectedColors;
+        this.makeColorsBrighter(selectedColors);
+        return selectedColors;
+    }
+    isMoreThanOneValueFieldOnCanvas(chartsLength, chartsValueFieldAmount) {
+        return (chartsLength > 1 || chartsValueFieldAmount > 1);
+    }
+    makeColorsBrighter(initialColors) {
+        for (let i = 0; i < initialColors.length; i++) {
+            initialColors[i] = chroma.mix(initialColors[i], 'white', 0.2).saturate(3).hex();
+        }
+    }
+    getStartIndex(chartIndex, chartsFieldsAmounts) {
+        let startIndex = 0;
+        for (let i = 0; i < chartIndex; i++) {
+            startIndex += chartsFieldsAmounts[i];
+        }
+        return startIndex;
+    }
+}

package/lib/model/chartStyleModel/chartStyleModel.d.ts

@@ -0,0 +1,9 @@
+import { ChartStyleConfig } from "../../designer/designerConfig";
+import { ChartStyle } from "../model";
+export declare class ChartStyleModelService {
+    private static standartColors;
+    static getCssClasses(chartIndex: number): string[];
+    static getChartStyle(elementsAmount: number, styleConfig: ChartStyleConfig): ChartStyle;
+    static getColorSet(baseColors: string[], elementsAmount: number): string[];
+    static checkAndGet(baseColors: string[]): string[];
+}

package/lib/model/chartStyleModel/chartStyleModel.js

@@ -0,0 +1,27 @@
+import * as chroma from "chroma-js";
+export class ChartStyleModelService {
+    static getCssClasses(chartIndex) {
+        const cssClasses = [`chart-${chartIndex}`];
+        return cssClasses;
+    }
+    static getChartStyle(elementsAmount, styleConfig) {
+        const baseColors = this.checkAndGet(styleConfig.baseColors);
+        return {
+            elementColors: this.getColorSet(baseColors, elementsAmount),
+            opacity: 1
+        };
+    }
+    static getColorSet(baseColors, elementsAmount) {
+        return chroma.scale(baseColors)
+            .mode('rgb')
+            .domain([0, 0.55, 0.75, 1])
+            .colors(elementsAmount <= 1 ? 2 : elementsAmount);
+    }
+    static checkAndGet(baseColors) {
+        if (baseColors.length === 0 || baseColors.filter(color => color === 'rgba(0, 0, 0, 0)' || !color).length > 0) {
+            return this.standartColors;
+        }
+        return baseColors;
+    }
+}
+ChartStyleModelService.standartColors = ["#209DE3", "#FF3131", "#FFBA00", "#20B078"];

package/lib/model/{dataManagerModel.d.ts → dataManagerModel/dataManagerModel.d.ts}

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

package/lib/model/{dataManagerModel.js → dataManagerModel/dataManagerModel.js}

@@ -1,25 +1,27 @@
-import { AxisModel } from "./featuresModel/axisModel";
-import { LegendCanvasModel } from "./featuresModel/legendModel/legendCanvasModel";
-import { MIN_DONUT_BLOCK_SIZE } from "./featuresModel/legendModel/legendModel";
-import { ModelHelper } from "./modelHelper";
+import { AxisModel } from "../featuresModel/axisModel";
+import { LegendCanvasModel } from "../featuresModel/legendModel/legendCanvasModel";
+import { LegendPolarMarginCalculator } from "../featuresModel/legendModel/polarMarginCalculator";
+import { ModelHelper } from "../modelHelper";
+import { MIN_DONUT_BLOCK_SIZE, PolarModel } from "../notations/polarModel";
+import { DataManagerModelService } from "./dataManagerModelService";
 export class DataManagerModel {
     static getPreparedData(data, allowableKeys, config) {
         const scopedData = this.getScopedData(data, allowableKeys, config);
         this.setDataType(scopedData, config);
         return scopedData;
     }
-    static getDataScope(config, margin, data, designerConfig, legendBlock) {
+    static initDataScope(config, data, designerConfig, legendBlock, modelInstance) {
         if (config.options.type === '2d' || config.options.type === 'interval') {
-            return this.getDataScopeFor2D(config.options, config.canvas.size, margin, data, designerConfig);
+            this.initDataScopeFor2D(config.options, modelInstance, data, designerConfig);
         }
         else if (config.options.type === 'polar') {
-            return this.getDataScopeForPolar(config.options, config.canvas.size, margin, data, legendBlock, designerConfig.canvas.legendBlock);
+            this.initDataScopeForPolar(config.options, modelInstance, data, legendBlock, designerConfig.canvas.legendBlock);
         }
     }
     static getDataValuesByKeyField(data, dataSourceName, keyFieldName) {
         return data[dataSourceName].map(dataRow => dataRow[keyFieldName]);
     }
-    static getDataScopeFor2D(configOptions, blockSize, margin, data, designerConfig) {
+    static initDataScopeFor2D(configOptions, modelInstance, data, designerConfig) {
         // Для interval всегда один элемент, так как там может быть только один столбик
         let itemsLength = 1;
         if (configOptions.type === '2d') {
@@ -29,48 +31,59 @@ export class DataManagerModel {
                 itemsLength = 1; // Если баров нет, то для одной записи выделяется столько же места, сколько для одного столбика
         }
         if (itemsLength !== 0) {
-            const axisLength = AxisModel.getAxisLength(configOptions.orientation, margin, blockSize);
+            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, itemsLength), dataLength, axisLength, designerConfig.canvas.chartOptions.bar);
             const allowableKeys = uniqueKeys.slice(0, limit);
-            return {
-                allowableKeys,
-                hidedRecordsAmount: dataLength - allowableKeys.length
-            };
+            const hidedRecordsAmount = dataLength - allowableKeys.length;
+            modelInstance.dataModel.initScope(this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel));
+        }
+        else {
+            const allKeys = this.getDataValuesByKeyField(data, configOptions.data.dataSource, configOptions.data.keyField.name);
+            modelInstance.dataModel.initScope(this.getMaximumPossibleScope(allKeys, modelInstance.dataModel));
         }
-        return {
-            allowableKeys: this.getDataValuesByKeyField(data, configOptions.data.dataSource, configOptions.data.keyField.name),
-            hidedRecordsAmount: 0
-        };
     }
-    static getDataScopeForPolar(configOptions, blockSize, margin, data, legendBlock, legendCanvas) {
-        const dataset = data[configOptions.data.dataSource];
+    static initDataScopeForPolar(configOptions, modelInstance, data, legendBlock, legendCanvas) {
+        const canvasModel = modelInstance.canvasModel;
         const keyFieldName = configOptions.data.keyField.name;
-        const keys = dataset.map(dataRow => dataRow[keyFieldName]);
+        const keys = data[configOptions.data.dataSource].map(dataRow => dataRow[keyFieldName]);
         if (!configOptions.legend.show) {
-            return {
-                allowableKeys: keys,
-                hidedRecordsAmount: 0
-            };
+            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;
+            }
         }
-        let position;
-        if (blockSize.width - margin.left - margin.right >= MIN_DONUT_BLOCK_SIZE)
-            position = 'right';
-        else
-            position = 'bottom';
-        let maxItemsNumber;
+        //TODO: global refactor of method
+        const allowableKeys = keys.slice(0, maxItemsNumber);
+        const hidedRecordsAmount = keys.length - maxItemsNumber;
+        const marginCalculator = new LegendPolarMarginCalculator();
+        marginCalculator.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) {
         if (position === 'right') {
-            maxItemsNumber = LegendCanvasModel.findElementsAmountByLegendSize(keys, position, legendCanvas.maxWidth, blockSize.height - margin.top - margin.bottom);
+            return LegendCanvasModel.findElementsAmountByLegendSize(keys, position, legendCanvas.maxWidth, canvasModel.getChartBlockHeight() - legendBlock.coordinate.bottom.margin.bottom);
         }
         else {
-            let marginBottom = margin.bottom - (legendBlock.coordinate.bottom.size === 0 ? legendBlock.coordinate.bottom.size : legendBlock.coordinate.bottom.size - legendBlock.coordinate.bottom.margin.bottom);
-            maxItemsNumber = LegendCanvasModel.findElementsAmountByLegendSize(keys, position, blockSize.width - margin.left - margin.right, blockSize.height - margin.top - marginBottom - legendBlock.coordinate.bottom.margin.bottom - MIN_DONUT_BLOCK_SIZE);
+            return LegendCanvasModel.findElementsAmountByLegendSize(keys, 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);
         }
-        return {
-            allowableKeys: keys.slice(0, maxItemsNumber),
-            hidedRecordsAmount: keys.length - maxItemsNumber
-        };
+    }
+    static getMaximumPossibleScope(keys, dataModel) {
+        return this.service.getMaximumPossibleAmount(keys, dataModel.getMaxRecordsAmount());
+    }
+    static limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel) {
+        return this.service.limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel.getMaxRecordsAmount());
     }
     /**
      * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
@@ -101,13 +114,7 @@ export class DataManagerModel {
         return data.filter(d => allowableKeys.findIndex(key => key === d[keyFieldName]) !== -1);
     }
     static setDataType(data, config) {
-        if (config.options.type === 'polar' || config.options.type === '2d') {
-            // Форматиривание для оси ключей пока не совсем верно установлено
-            // if(config.options.data.keyField.format === 'date') {
-            //     data[config.options.data.dataSource] = this.getTypedData(data[config.options.data.dataSource], config.options.data.keyField);
-            // }
-        }
-        else if (config.options.type === 'interval') {
+        if (config.options.type === 'interval') {
             const chart = config.options.chart;
             if (chart.data.valueField1.format === 'date') {
                 data[config.options.data.dataSource] = this.getTypedData(data[config.options.data.dataSource], chart.data.valueField1);
@@ -135,3 +142,4 @@ export class DataManagerModel {
         return dataLength;
     }
 }
+DataManagerModel.service = new DataManagerModelService();

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

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

package/lib/model/dataManagerModel/dataManagerModelService.js

@@ -0,0 +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
+        };
+    }
+}

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

@@ -1,18 +1,20 @@
-import { AxisPosition, ChartOrientation, DataOptions, MdtChartsDataSource, DiscreteAxisOptions, NumberAxisOptions, Size, TwoDimensionalChart } from "../../config/config";
-import { AxisLabelPosition, AxisModelOptions, BlockMargin, Orient } from "../model";
+import { AxisPosition, ChartOrientation, MdtChartsDataSource, NumberAxisOptions, AxisLabelPosition, MdtChartsTwoDimensionalOptions, DiscreteAxisOptions } from "../../config/config";
+import { AxisModelOptions, Orient } 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;
 }
 export declare class AxisModel {
-    static getKeyAxis(charts: TwoDimensionalChart[], data: MdtChartsDataSource, dataOptions: DataOptions, orient: ChartOrientation, axisConfig: DiscreteAxisOptions, labelConfig: AxisLabelCanvas, margin: BlockMargin, blockSize: Size, tooltipSettings: TooltipSettings): AxisModelOptions;
-    static getValueAxis(orient: ChartOrientation, axisConfig: NumberAxisOptions, labelConfig: AxisLabelCanvas, margin: BlockMargin, blockSize: Size): AxisModelOptions;
-    static getAxisLength(chartOrientation: ChartOrientation, margin: BlockMargin, blockSize: Size): number;
+    private static service;
+    static getKeyAxis(options: MdtChartsTwoDimensionalOptions, data: MdtChartsDataSource, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, tooltipSettings: TooltipSettings): AxisModelOptions;
+    static getValueAxis(orient: ChartOrientation, axisConfig: NumberAxisOptions, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel): AxisModelOptions;
+    static getAxisLength(chartOrientation: ChartOrientation, canvasModel: CanvasModel): number;
     static getAxisOrient(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition): Orient;
-    static getAxisTranslateX(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition, margin: BlockMargin, blockWidth: number): number;
-    static getAxisTranslateY(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition, margin: BlockMargin, blockHeight: number): number;
-    static getKeyAxisLabelPosition(margin: BlockMargin, blockSize: Size, scopedDataLength: number): AxisLabelPosition;
+    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: any[]): LabelSize;
 }