mdt-charts 1.11.1 → 1.12.3

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

@@ -1,14 +1,11 @@
 import { ChartNotation, Size } from "../../../config/config";
-import { ILegendModel, LegendBlockModel, LegendPosition, Orient } from "../../model";
+import { ILegendModel, LegendBlockModel, Orient } from "../../model";
 import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
 import { LegendItemsDirection } from "./legendCanvasModel";
-/** If donut block has width less than this const, legend change postion from "right" to "bottom" */
-export declare const MIN_DONUT_BLOCK_SIZE = 260;
 export declare class LegendModel {
     static getLegendSize(chartNotation: ChartNotation, position: Orient, texts: string[], legendMaxWidth: number, blockSize: Size, legendBlockModel: LegendBlockModel): number;
     static getBaseLegendBlockModel(notation: ChartNotation, canvasModel: CanvasModel): LegendBlockModel;
     static getLegendModel(chartNotation: ChartNotation, legendShow: boolean, canvasModel: CanvasModel): ILegendModel;
     static getLegendItemClass(itemsPosition: LegendItemsDirection): string;
-    static getMarginClass(legendPosition: LegendPosition): string;
     private static getLegendWidth;
 }

package/lib/model/featuresModel/legendModel/legendModel.js

@@ -1,16 +1,16 @@
 import { ModelHelper } from "../../modelHelper";
+import { PolarModel } from "../../notations/polar/polarModel";
 import { LegendCanvasModel } from "./legendCanvasModel";
-/** If donut block has width less than this const, legend change postion from "right" to "bottom" */
-export const MIN_DONUT_BLOCK_SIZE = 260;
 export class LegendModel {
     static getLegendSize(chartNotation, position, texts, legendMaxWidth, blockSize, legendBlockModel) {
         if (position === 'left' || position === 'right')
             return this.getLegendWidth(texts, legendMaxWidth);
+        //TODO: rm duplicate
         if (chartNotation === '2d' || chartNotation === 'interval') {
-            return LegendCanvasModel.getLegendHeight(texts, blockSize.width, legendBlockModel.coordinate[position].margin.left, legendBlockModel.coordinate[position].margin.right, 'row', position);
+            return LegendCanvasModel.getLegendHeight(texts, blockSize.width - legendBlockModel.coordinate[position].margin.left - legendBlockModel.coordinate[position].margin.right, 'row', position);
         }
         else if (chartNotation === 'polar') {
-            const size = LegendCanvasModel.getLegendHeight(texts, blockSize.width, legendBlockModel.coordinate[position].margin.left, legendBlockModel.coordinate[position].margin.right, 'column', position);
+            const size = LegendCanvasModel.getLegendHeight(texts, blockSize.width - legendBlockModel.coordinate[position].margin.left - legendBlockModel.coordinate[position].margin.right, 'row', position);
             return size;
         }
     }
@@ -25,17 +25,17 @@ export class LegendModel {
                 },
                 bottom: {
                     size: 0,
-                    margin: { top: 0, bottom: 20, left: 20, right: 20 },
+                    margin: { top: 0, bottom: 20, left: 0, right: 0 },
                     pad: 0
                 },
                 right: {
                     size: 0,
-                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 0, right: mr },
+                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 10, right: 0 },
                     pad: 0
                 },
                 top: {
                     size: 0,
-                    margin: { top: 20, bottom: 0, left: 20, right: 20 },
+                    margin: { top: 10, bottom: 10, left: 20, right: 20 },
                     pad: canvasModel.titleCanvas.getAllNeededSpace()
                 }
             },
@@ -43,13 +43,15 @@ export class LegendModel {
         };
     }
     static getLegendModel(chartNotation, legendShow, canvasModel) {
+        if (!legendShow)
+            return {
+                position: 'off'
+            };
         let legendPosition = 'off';
-        if (legendShow) {
-            if (chartNotation === '2d' || chartNotation === 'interval')
-                legendPosition = 'top';
-            else if (chartNotation === 'polar') {
-                legendPosition = canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE ? 'bottom' : 'right';
-            }
+        if (chartNotation === '2d' || chartNotation === 'interval')
+            legendPosition = 'top';
+        else if (chartNotation === 'polar') {
+            legendPosition = PolarModel.getLegendPositionByBlockSize(canvasModel);
         }
         return {
             position: legendPosition
@@ -58,9 +60,6 @@ export class LegendModel {
     static getLegendItemClass(itemsPosition) {
         return itemsPosition === 'column' ? 'legend-item-row' : 'legend-item-inline';
     }
-    static getMarginClass(legendPosition) {
-        return legendPosition === 'right' ? 'mt-15' : 'mt-10';
-    }
     static getLegendWidth(texts, legendMaxWidth) {
         let longestText = '';
         let biggestScore = 0;

package/lib/model/featuresModel/legendModel/polarMarginCalculator.d.ts

@@ -0,0 +1,11 @@
+import { MdtChartsDataSource, MdtChartsPolarOptions } from "../../../config/config";
+import { LegendBlockModel } from "../../model";
+import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
+import { ModelInstance } from "../../modelInstance/modelInstance";
+export declare class LegendPolarMarginCalculator {
+    recalcMargin(modelInstance: ModelInstance, options: MdtChartsPolarOptions, legendMaxWidth: number, legendBlockModel: LegendBlockModel, data: MdtChartsDataSource): void;
+    updateMargin(legendPosition: "right" | "bottom", canvasModel: CanvasModel, legendBlockModel: LegendBlockModel, size: number): void;
+    private updateMarginObj;
+    private getLegendSize;
+    private getLegendItemsContent;
+}

package/lib/model/featuresModel/legendModel/polarMarginCalculator.js

@@ -0,0 +1,42 @@
+import { DataManagerModel } from "../../dataManagerModel/dataManagerModel";
+import { MarginModel } from "../../marginModel";
+import { MIN_DONUT_BLOCK_SIZE } from "../../notations/polar/polarModel";
+import { LegendModel } from "./legendModel";
+export class LegendPolarMarginCalculator {
+    recalcMargin(modelInstance, options, legendMaxWidth, legendBlockModel, data) {
+        const canvasModel = modelInstance.canvasModel;
+        let legendPosition = LegendModel.getLegendModel(options.type, options.legend.show, modelInstance.canvasModel).position;
+        modelInstance.canvasModel.legendCanvas.setPosition(legendPosition);
+        if (legendPosition === "off")
+            return;
+        let legendSize = this.getLegendSize(options, legendMaxWidth, legendBlockModel, data, canvasModel, legendPosition);
+        if (legendPosition === "right" && canvasModel.getChartBlockWidth() - legendSize < MIN_DONUT_BLOCK_SIZE) {
+            legendSize = this.getLegendSize(options, legendMaxWidth, legendBlockModel, data, canvasModel, "bottom");
+            legendPosition = "bottom";
+            modelInstance.canvasModel.legendCanvas.setPosition(legendPosition);
+        }
+        if (legendSize !== 0) {
+            canvasModel.increaseMarginSide(legendPosition, legendSize);
+            MarginModel.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
+        }
+        legendBlockModel.coordinate[legendPosition].size = legendSize;
+    }
+    updateMargin(legendPosition, canvasModel, legendBlockModel, size) {
+        canvasModel.legendCanvas.setPosition(legendPosition);
+        this.updateMarginObj(legendBlockModel, legendPosition, size, canvasModel);
+    }
+    updateMarginObj(legendBlockModel, legendPosition, legendSize, canvasModel) {
+        if (legendSize !== 0) {
+            canvasModel.increaseMarginSide(legendPosition, legendSize);
+            MarginModel.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
+        }
+        legendBlockModel.coordinate[legendPosition].size = legendSize;
+    }
+    getLegendSize(options, legendMaxWidth, legendBlockModel, data, canvasModel, legendPosition) {
+        const legendItemsContent = this.getLegendItemsContent(options, data);
+        return LegendModel.getLegendSize(options.type, legendPosition, legendItemsContent, legendMaxWidth, canvasModel.getBlockSize(), legendBlockModel);
+    }
+    getLegendItemsContent(options, data) {
+        return DataManagerModel.getDataValuesByKeyField(data, options.data.dataSource, options.data.keyField.name);
+    }
+}

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

@@ -1,18 +1,18 @@
 import { ScaleKeyModel, ScaleKeyType, ScaleValueModel, ScaleValueType } from "../model";
-import { AxisPosition, NumberDomain, IntervalChart, TwoDimensionalChart, MdtChartsTwoDimensionalOptions, ChartOrientation, MdtChartsDataSource } from "../../config/config";
+import { AxisPosition, NumberDomain, IntervalChart, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions, ChartOrientation, MdtChartsDataSource } from "../../config/config";
 import { CanvasModel } from "../modelInstance/canvasModel/canvasModel";
 export declare enum ScaleType {
     Key = 0,
     Value = 1
 }
 export declare class ScaleModel {
-    static getScaleKey(allowableKeys: string[], orient: ChartOrientation, canvasModel: CanvasModel, charts: TwoDimensionalChart[], barCharts: TwoDimensionalChart[]): ScaleKeyModel;
+    static getScaleKey(allowableKeys: string[], orient: ChartOrientation, canvasModel: CanvasModel, charts: MdtChartsTwoDimensionalChart[], barCharts: MdtChartsTwoDimensionalChart[]): ScaleKeyModel;
     static getScaleLinear(options: MdtChartsTwoDimensionalOptions, data: MdtChartsDataSource, canvasModel: CanvasModel): ScaleValueModel;
     static getRangePeek(scaleType: ScaleType, chartOrientation: string, canvasModel: CanvasModel): number;
     static getDateValueDomain(data: MdtChartsDataSource, chart: IntervalChart, keyAxisPosition: AxisPosition, dataSource: string): [Date, Date];
     static getLinearDomain(configDomain: NumberDomain, data: MdtChartsDataSource, configOptions: MdtChartsTwoDimensionalOptions): [number, number];
-    static getScaleKeyType(charts: TwoDimensionalChart[]): ScaleKeyType;
-    static getScaleValueType(charts: TwoDimensionalChart[] | IntervalChart[]): ScaleValueType;
-    static getElementsAmount(barCharts: TwoDimensionalChart[]): number;
-    static getScaleMaxValue(charts: TwoDimensionalChart[], dataSource: string, data: MdtChartsDataSource): number;
+    static getScaleKeyType(charts: MdtChartsTwoDimensionalChart[]): ScaleKeyType;
+    static getScaleValueType(charts: MdtChartsTwoDimensionalChart[] | IntervalChart[]): ScaleValueType;
+    static getElementsAmount(barCharts: MdtChartsTwoDimensionalChart[]): number;
+    static getScaleMaxValue(charts: MdtChartsTwoDimensionalChart[], dataSource: string, data: MdtChartsDataSource): number;
 }

package/lib/model/featuresModel/titleModel.js

@@ -4,10 +4,10 @@ export class TitleModel {
         const pad = titleText ? defaultPads : 0;
         return {
             margin: {
-                bottom: 0,
-                left: pad,
-                right: pad,
-                top: pad
+                bottom: 10,
+                left: 0,
+                right: 0,
+                top: 0
             },
             size: pad,
             pad: 0

package/lib/model/marginModel.d.ts

@@ -1,7 +1,8 @@
 import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
 import { DesignerConfig } from "../designer/designerConfig";
-import { DataScope, LegendBlockModel, OtherCommonComponents, PolarOptionsModel } from "./model";
+import { DataScope, LegendBlockModel, Orient, OtherCommonComponents, PolarOptionsModel } from "./model";
 import { ModelInstance } from "./modelInstance/modelInstance";
+import { CanvasModel } from "./modelInstance/canvasModel/canvasModel";
 export declare const AXIS_HORIZONTAL_LABEL_PADDING = 15;
 export declare const AXIS_VERTICAL_LABEL_PADDING = 10;
 export declare class MarginModel {
@@ -13,7 +14,7 @@ export declare class MarginModel {
     private static recalcHorizontalMarginByAxisLabelWidth;
     private static recalcMarginWithLegend;
     private static getLegendItemsContent;
-    private static appendToGlobalMarginValuesLegendMargin;
+    static appendToGlobalMarginValuesLegendMargin(canvasModel: CanvasModel, position: Orient, legendBlockModel: LegendBlockModel): void;
     private static clearMarginByLegendBlockPosition;
     private static recalcMarginByTitle;
 }

package/lib/model/marginModel.js

@@ -1,8 +1,9 @@
 import { AxisModel } from "./featuresModel/axisModel";
-import { DataManagerModel } from "./dataManagerModel";
-import { LegendModel, MIN_DONUT_BLOCK_SIZE } from "./featuresModel/legendModel/legendModel";
+import { DataManagerModel } from "./dataManagerModel/dataManagerModel";
+import { LegendModel } from "./featuresModel/legendModel/legendModel";
 import { AxisType } from "./modelBuilder";
 import { TwoDimensionalModel } from "./notations/twoDimensionalModel";
+import { PolarModel } from "./notations/polar/polarModel";
 export const AXIS_HORIZONTAL_LABEL_PADDING = 15;
 export const AXIS_VERTICAL_LABEL_PADDING = 10;
 export class MarginModel {
@@ -25,10 +26,9 @@ export class MarginModel {
     }
     static recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, legendBlockModel, dataScope, options) {
         const canvasModel = modelInstance.canvasModel;
-        let position = LegendModel.getLegendModel(config.options.type, config.options.legend.show, modelInstance.canvasModel).position;
+        let position = canvasModel.legendCanvas.getPosition();
         if (position !== 'off') {
-            if (position === 'right' && canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE)
-                position = 'bottom';
+            position = PolarModel.getLegendPositionByBlockSize(canvasModel); // reset position
             this.clearMarginByLegendBlockPosition(canvasModel, legendBlockModel);
             let allowableKeys = [...dataScope.allowableKeys];
             if (dataScope.hidedRecordsAmount !== 0 && position === 'bottom')
@@ -42,7 +42,7 @@ export class MarginModel {
     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);
-            const axisConfig = AxisModel.getKeyAxisLabelPosition(modelInstance.canvasModel, dataScope.allowableKeys.length);
+            const axisConfig = AxisModel.getKeyAxisLabelPosition(modelInstance.canvasModel, dataScope.allowableKeys.length, config.options.axis.key);
             const marginOrient = config.options.axis.key.position === 'end' ? 'bottom' : 'top';
             if (axisConfig === 'rotated')
                 modelInstance.canvasModel.setMarginSide(marginOrient, modelInstance.canvasModel.getMarginSide(marginOrient) + (axisLabelSize.width - axisLabelSize.height));
@@ -80,8 +80,12 @@ export class MarginModel {
         }
     }
     static recalcMarginWithLegend(modelInstance, config, legendMaxWidth, legendBlockModel, data) {
+        if (config.options.type === "polar") {
+            return;
+        }
         const canvasModel = modelInstance.canvasModel;
         const legendPosition = LegendModel.getLegendModel(config.options.type, config.options.legend.show, modelInstance.canvasModel).position;
+        modelInstance.canvasModel.legendCanvas.setPosition(legendPosition);
         if (legendPosition !== 'off') {
             const legendItemsContent = this.getLegendItemsContent(config.options, data);
             const legendSize = LegendModel.getLegendSize(config.options.type, legendPosition, legendItemsContent, legendMaxWidth, canvasModel.getBlockSize(), legendBlockModel);
@@ -123,6 +127,6 @@ export class MarginModel {
         });
     }
     static recalcMarginByTitle(canvasModel, titleBlockModel) {
-        canvasModel.increaseMarginSide("top", titleBlockModel.margin.top + titleBlockModel.size);
+        canvasModel.increaseMarginSide("top", titleBlockModel.margin.top + titleBlockModel.size + titleBlockModel.margin.bottom);
     }
 }

package/lib/model/model.d.ts

@@ -1,19 +1,18 @@
-import { ChartOrientation, MdtChartsColorField, IntervalChartType, PolarChartType, Size, TooltipOptions, TwoDimensionalChartType } from "../config/config";
+import { ChartOrientation, MdtChartsColorField, IntervalChartType, PolarChartType, Size, TooltipOptions, TwoDimensionalChartType, AxisLabelPosition } from "../config/config";
 import { DataType, DonutOptionsCanvas, Formatter, TooltipSettings, Transitions } from "../designer/designerConfig";
 declare type AxisType = "key" | "value";
 export declare type Orient = "top" | "bottom" | "left" | "right";
 export declare type ScaleKeyType = "band" | "point";
 export declare type ScaleValueType = "linear" | "datetime";
-export declare type AxisLabelPosition = "straight" | "rotated";
 export declare type LegendPosition = "off" | "top" | "bottom" | "left" | "right";
 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;
@@ -137,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,7 +1,7 @@
 import { MarginModel } from './marginModel';
 import { TwoDimensionalModel } from './notations/twoDimensionalModel';
-import { PolarModel } from './notations/polarModel';
-import { DataManagerModel } from './dataManagerModel';
+import { PolarModel } from './notations/polar/polarModel';
+import { DataManagerModel } from './dataManagerModel/dataManagerModel';
 import { IntervalModel } from './notations/intervalModel';
 import { OtherComponentsModel } from './featuresModel/otherComponents';
 import { ConfigValidator } from './configsValidator/configValidator';
@@ -69,17 +69,17 @@ export function assembleModel(config, data, designerConfig) {
     resetFalsyValues(data, config.options.data.keyField.name);
     const otherComponents = OtherComponentsModel.getOtherComponentsModel({ elementsOptions: designerConfig.elementsOptions, notation: config.options.type, title: config.options.title }, modelInstance);
     MarginModel.initMargin(designerConfig, config, otherComponents, data, modelInstance);
-    const dataScope = DataManagerModel.getDataScope(config, data, designerConfig, otherComponents.legendBlock, modelInstance);
-    const preparedData = DataManagerModel.getPreparedData(data, dataScope.allowableKeys, config);
+    DataManagerModel.initDataScope(config, data, designerConfig, otherComponents.legendBlock, modelInstance);
+    const preparedData = DataManagerModel.getPreparedData(data, modelInstance.dataModel.getAllowableKeys(), config);
     if (config.options.type === '2d' && config.options.axis.key.visibility)
-        MarginModel.recalcMarginByVerticalAxisLabel(modelInstance, config, designerConfig, dataScope);
+        MarginModel.recalcMarginByVerticalAxisLabel(modelInstance, config, designerConfig, modelInstance.dataModel.getScope());
     const blockCanvas = getBlockCanvas(config, modelInstance);
     const chartBlock = getChartBlockModel(modelInstance);
-    const options = getOptions(config, designerConfig, modelInstance, dataScope, preparedData);
-    const dataSettings = getDataSettings(dataScope, designerConfig);
+    const options = getOptions(config, designerConfig, modelInstance, modelInstance.dataModel.getScope(), preparedData);
+    const dataSettings = getDataSettings(modelInstance.dataModel.getScope(), designerConfig);
     const transitions = getTransitions(designerConfig);
-    if (options.type === 'polar')
-        MarginModel.recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, otherComponents.legendBlock, dataScope, options);
+    // if (options.type === 'polar')
+    //     MarginModel.recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, otherComponents.legendBlock, modelInstance.dataModel.getScope(), options);
     modelInstance.canvasModel.roundMargin();
     return {
         blockCanvas,

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

@@ -1,9 +1,11 @@
 import { Size } from "../../../config/config";
 import { BlockMargin } from "../../model";
+import { LegendCanvasModelInstance } from "./legendCanvasModel";
 import { TitleCanvasModel } from "./titleCanvas";
 declare type MarginSide = keyof BlockMargin;
 export declare class CanvasModel {
     titleCanvas: TitleCanvasModel;
+    legendCanvas: LegendCanvasModelInstance;
     private blockSize;
     private margin;
     constructor();

package/lib/model/modelInstance/canvasModel/canvasModel.js

@@ -1,7 +1,9 @@
+import { LegendCanvasModelInstance } from "./legendCanvasModel";
 import { TitleCanvasModel } from "./titleCanvas";
 export class CanvasModel {
     constructor() {
         this.titleCanvas = new TitleCanvasModel();
+        this.legendCanvas = new LegendCanvasModelInstance();
     }
     initMargin(margin) {
         this.margin = margin;

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

@@ -0,0 +1,7 @@
+import { ILegendModel, LegendPosition } from "../../model";
+export declare class LegendCanvasModelInstance {
+    private position;
+    getModel(): ILegendModel;
+    getPosition(): LegendPosition;
+    setPosition(position: LegendPosition): void;
+}

package/lib/model/modelInstance/canvasModel/legendCanvasModel.js

@@ -0,0 +1,13 @@
+export class LegendCanvasModelInstance {
+    getModel() {
+        return {
+            position: this.position
+        };
+    }
+    getPosition() {
+        return this.position;
+    }
+    setPosition(position) {
+        this.position = position;
+    }
+}

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

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

package/lib/model/modelInstance/dataModel.js

@@ -0,0 +1,23 @@
+export const DEFAULT_MAX_RECORDS_AMOUNT = 50;
+export class DataModelInstance {
+    constructor() {
+        this.maxRecordsAmount = DEFAULT_MAX_RECORDS_AMOUNT;
+    }
+    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/modelInstance.d.ts

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

package/lib/model/modelInstance/modelInstance.js

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

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/intervalModel.js

@@ -1,7 +1,6 @@
 import { AxisModel } from "../featuresModel/axisModel";
 import { ChartStyleModelService } from "../chartStyleModel/chartStyleModel";
-import { DataManagerModel } from "../dataManagerModel";
-import { LegendModel } from "../featuresModel/legendModel/legendModel";
+import { DataManagerModel } from "../dataManagerModel/dataManagerModel";
 import { AxisType } from "../modelBuilder";
 import { ScaleModel, ScaleType } from "../featuresModel/scaleModel";
 import { TwoDimensionalModel } from "./twoDimensionalModel";
@@ -10,7 +9,7 @@ export class IntervalModel {
         const options = config.options;
         const canvasModel = modelInstance.canvasModel;
         return {
-            legend: LegendModel.getLegendModel(config.options.type, config.options.legend.show, canvasModel),
+            legend: canvasModel.legendCanvas.getModel(),
             title: options.title,
             selectable: !!options.selectable,
             orient: options.orientation,

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))
+            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.reduce((acc, row) => acc + row[dataOptions.valueFieldName], 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, dataRows: 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, dataRows) {
+        return {
+            padAngle: settingsFromConfig.padAngle,
+            thickness: this.getThicknessOptions(settingsFromConfig.thickness),
+            aggregator: this.getAggregatorOptions(settingsFromConfig, chartOptions, dataRows)
+        };
+    }
+    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, dataRows) {
+        return {
+            margin: settingsFromConfig.aggregatorPad,
+            content: this.aggregatorService.getContent(chartOptions.aggregator, {
+                rows: dataRows,
+                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;
+    }
+}