mdt-charts 1.12.2 → 1.12.6

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

@@ -1,5 +1,5 @@
 import { ModelHelper } from "../../modelHelper";
-import { PolarModel } from "../../notations/polarModel";
+import { PolarModel } from "../../notations/polar/polarModel";
 import { LegendCanvasModel } from "./legendCanvasModel";
 export class LegendModel {
     static getLegendSize(chartNotation, position, texts, legendMaxWidth, blockSize, legendBlockModel) {
@@ -30,12 +30,12 @@ export class LegendModel {
                 },
                 right: {
                     size: 0,
-                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 10, right: 0 },
+                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 5, right: 0 },
                     pad: 0
                 },
                 top: {
                     size: 0,
-                    margin: { top: 10, bottom: 10, left: 20, right: 20 },
+                    margin: { top: 5, bottom: 10, left: 0, right: 0 },
                     pad: canvasModel.titleCanvas.getAllNeededSpace()
                 }
             },

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

@@ -1,6 +1,6 @@
 import { DataManagerModel } from "../../dataManagerModel/dataManagerModel";
 import { MarginModel } from "../../marginModel";
-import { MIN_DONUT_BLOCK_SIZE } from "../../notations/polarModel";
+import { MIN_DONUT_BLOCK_SIZE } from "../../notations/polar/polarModel";
 import { LegendModel } from "./legendModel";
 export class LegendPolarMarginCalculator {
     recalcMargin(modelInstance, options, legendMaxWidth, legendBlockModel, data) {

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

@@ -0,0 +1,20 @@
+import { ScaleLinear, ScaleTime } from "d3-scale";
+import { ChartOrientation, DiscreteAxisOptions } from "../../../config/config";
+import { ScaleValueModel } from "../../model";
+import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
+export declare const keyAxisLabelVerticalLog = "keyAxisLabel_vertical_margin_log";
+export declare const keyAxisLabelHorizontalLog = "keyAxisLabel_horizontal_margin_log";
+interface ScaleInfo {
+    scale: ScaleValueModel;
+    scaleFn: ScaleLinear<number, number, never> | ScaleTime<number, number, never>;
+}
+/**
+ * Предназначен для получения нового scaleValue и уменьшения globalMargin, если ось ключей находится где-то внутри chartBlock, а не на его границе
+ */
+export declare class ScaleAxisRecalcer {
+    private generateScaleLinear;
+    constructor(generateScaleLinear: () => ScaleValueModel);
+    recalculateMargin(canvasModel: CanvasModel, chartOrientation: ChartOrientation, keyAxis: DiscreteAxisOptions): void;
+    getScaleValue(): ScaleInfo;
+}
+export {};

package/lib/model/featuresModel/scaleModel/scaleAxisRecalcer.js

@@ -0,0 +1,31 @@
+import { Scale } from "../../../engine/features/scale/scale";
+export const keyAxisLabelVerticalLog = "keyAxisLabel_vertical_margin_log";
+export const keyAxisLabelHorizontalLog = "keyAxisLabel_horizontal_margin_log";
+/**
+ * Предназначен для получения нового scaleValue и уменьшения globalMargin, если ось ключей находится где-то внутри chartBlock, а не на его границе
+ */
+export class ScaleAxisRecalcer {
+    constructor(generateScaleLinear) {
+        this.generateScaleLinear = generateScaleLinear;
+    }
+    recalculateMargin(canvasModel, chartOrientation, keyAxis) {
+        const scaleValue = this.generateScaleLinear();
+        //TODO: rm import from engine
+        const scaleValueFn = Scale.getScaleValue(scaleValue);
+        const coordinateOnChartBlock = (keyAxis.position === "start"
+            ? scaleValueFn(0)
+            : (chartOrientation === "vertical"
+                ? canvasModel.getChartBlockHeight()
+                : canvasModel.getChartBlockWidth()) - scaleValueFn(0));
+        const key = chartOrientation === "vertical" ? keyAxisLabelVerticalLog : keyAxisLabelHorizontalLog;
+        const logInfo = canvasModel.marginService.getDataByKey(key);
+        canvasModel.decreaseMarginSide(logInfo.side, logInfo.byValue - coordinateOnChartBlock < 0 ? logInfo.byValue : coordinateOnChartBlock);
+    }
+    getScaleValue() {
+        const scale = this.generateScaleLinear();
+        return {
+            scale,
+            scaleFn: Scale.getScaleValue(scale)
+        };
+    }
+}

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

@@ -0,0 +1,19 @@
+import { ScaleKeyModel, ScaleKeyType, ScaleValueModel, ScaleValueType } from "../../model";
+import { AxisPosition, NumberDomain, IntervalChart, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions, ChartOrientation, MdtChartsDataSource, MdtChartsDataRow } 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: 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: MdtChartsTwoDimensionalChart[]): ScaleKeyType;
+    static getScaleValueType(charts: MdtChartsTwoDimensionalChart[] | IntervalChart[]): ScaleValueType;
+    static getElementsAmount(barCharts: MdtChartsTwoDimensionalChart[]): number;
+    static getScaleMaxValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;
+    static getScaleMinValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;
+}

package/lib/model/featuresModel/scaleModel/scaleModel.js

@@ -0,0 +1,115 @@
+import { ModelHelper } from "../../modelHelper";
+export var ScaleType;
+(function (ScaleType) {
+    ScaleType[ScaleType["Key"] = 0] = "Key";
+    ScaleType[ScaleType["Value"] = 1] = "Value";
+})(ScaleType || (ScaleType = {}));
+export class ScaleModel {
+    static getScaleKey(allowableKeys, orient, canvasModel, charts, barCharts) {
+        return {
+            domain: allowableKeys,
+            range: {
+                start: 0,
+                end: ScaleModel.getRangePeek(ScaleType.Key, orient, canvasModel)
+            },
+            type: ScaleModel.getScaleKeyType(charts),
+            elementsAmount: this.getElementsAmount(barCharts)
+        };
+    }
+    static getScaleLinear(options, data, canvasModel) {
+        return {
+            domain: ScaleModel.getLinearDomain(options.axis.value.domain, data, options),
+            range: {
+                start: 0,
+                end: ScaleModel.getRangePeek(ScaleType.Value, options.orientation, canvasModel)
+            },
+            type: ScaleModel.getScaleValueType(options.charts)
+        };
+    }
+    static getRangePeek(scaleType, chartOrientation, canvasModel) {
+        if (chartOrientation === 'vertical')
+            return scaleType === ScaleType.Key
+                ? canvasModel.getChartBlockWidth()
+                : canvasModel.getChartBlockHeight();
+        return scaleType === ScaleType.Key
+            ? canvasModel.getChartBlockHeight()
+            : canvasModel.getChartBlockWidth();
+    }
+    static getDateValueDomain(data, chart, keyAxisPosition, dataSource) {
+        const minMax = ModelHelper.getMinAndMaxOfIntervalData(data, dataSource, chart);
+        let domainPeekMin = minMax[0];
+        let domainPeekMax = minMax[1];
+        if (keyAxisPosition === 'start')
+            return [domainPeekMin, domainPeekMax];
+        return [domainPeekMax, domainPeekMin];
+    }
+    static getLinearDomain(configDomain, data, configOptions) {
+        let domainPeekMin;
+        let domainPeekMax;
+        if (configDomain.start === -1)
+            domainPeekMin = this.getScaleMinValue(configOptions.charts, data[configOptions.data.dataSource]);
+        else
+            domainPeekMin = configDomain.start;
+        if (configDomain.end === -1)
+            domainPeekMax = this.getScaleMaxValue(configOptions.charts, data[configOptions.data.dataSource]);
+        else
+            domainPeekMax = configDomain.end;
+        if (configOptions.axis.key.position === 'start')
+            return [domainPeekMin, domainPeekMax];
+        return [domainPeekMax, domainPeekMin];
+    }
+    static getScaleKeyType(charts) {
+        if (charts.findIndex((chart) => chart.type === 'bar') === -1)
+            return 'point';
+        return 'band';
+    }
+    static getScaleValueType(charts) {
+        if (charts.findIndex((chart) => chart.type === 'gantt') !== -1)
+            return 'datetime';
+        return 'linear';
+    }
+    static getElementsAmount(barCharts) {
+        if (barCharts.length === 0)
+            return 1;
+        let barsAmount = 0;
+        barCharts.forEach(chart => {
+            if (chart.isSegmented)
+                barsAmount += 1; // Если бар сегментированный, то все valueFields являются частями одного бара
+            else
+                barsAmount += chart.data.valueFields.length;
+        });
+        return barsAmount;
+    }
+    static getScaleMaxValue(charts, dataRows) {
+        let max = 0;
+        charts.forEach(chart => {
+            dataRows.forEach(dataRow => {
+                let sumInRow = 0;
+                chart.data.valueFields.forEach(field => {
+                    if (chart.isSegmented)
+                        sumInRow += dataRow[field.name];
+                    else if (dataRow[field.name] > sumInRow)
+                        sumInRow = dataRow[field.name];
+                });
+                if (max < sumInRow)
+                    max = sumInRow;
+            });
+        });
+        return max;
+    }
+    static getScaleMinValue(charts, dataRows) {
+        let min = 0;
+        charts.forEach(chart => {
+            dataRows.forEach(dataRow => {
+                let sumInRow = 0;
+                chart.data.valueFields.forEach(field => {
+                    if (dataRow[field.name] < sumInRow)
+                        sumInRow = dataRow[field.name];
+                });
+                if (min > sumInRow)
+                    min = sumInRow;
+            });
+        });
+        return min;
+    }
+}

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

@@ -1,18 +1,19 @@
 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, MdtChartsDataRow } 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[], dataRows: MdtChartsDataRow[]): number;
+    static getScaleMinValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;
 }

package/lib/model/featuresModel/scaleModel.js

@@ -47,11 +47,11 @@ export class ScaleModel {
         let domainPeekMin;
         let domainPeekMax;
         if (configDomain.start === -1)
-            domainPeekMin = 0;
+            domainPeekMin = this.getScaleMinValue(configOptions.charts, data[configOptions.data.dataSource]);
         else
             domainPeekMin = configDomain.start;
         if (configDomain.end === -1)
-            domainPeekMax = this.getScaleMaxValue(configOptions.charts, configOptions.data.dataSource, data);
+            domainPeekMax = this.getScaleMaxValue(configOptions.charts, data[configOptions.data.dataSource]);
         else
             domainPeekMax = configDomain.end;
         if (configOptions.axis.key.position === 'start')
@@ -80,10 +80,10 @@ export class ScaleModel {
         });
         return barsAmount;
     }
-    static getScaleMaxValue(charts, dataSource, data) {
+    static getScaleMaxValue(charts, dataRows) {
         let max = 0;
         charts.forEach(chart => {
-            data[dataSource].forEach(dataRow => {
+            dataRows.forEach(dataRow => {
                 let sumInRow = 0;
                 chart.data.valueFields.forEach(field => {
                     if (chart.isSegmented)
@@ -97,4 +97,19 @@ export class ScaleModel {
         });
         return max;
     }
+    static getScaleMinValue(charts, dataRows) {
+        let min = 0;
+        charts.forEach(chart => {
+            dataRows.forEach(dataRow => {
+                let sumInRow = 0;
+                chart.data.valueFields.forEach(field => {
+                    if (dataRow[field.name] < sumInRow)
+                        sumInRow = dataRow[field.name];
+                });
+                if (min > sumInRow)
+                    min = sumInRow;
+            });
+        });
+        return min;
+    }
 }

package/lib/model/featuresModel/titleModel.js

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

package/lib/model/marginModel.d.ts

@@ -1,13 +1,12 @@
 import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
 import { DesignerConfig } from "../designer/designerConfig";
-import { DataScope, LegendBlockModel, Orient, OtherCommonComponents, PolarOptionsModel } from "./model";
+import { DataScope, LegendBlockModel, Orient, OtherCommonComponents } 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 {
     static initMargin(designerConfig: DesignerConfig, config: MdtChartsConfig, otherComponents: OtherCommonComponents, data: MdtChartsDataSource, modelInstance: ModelInstance): void;
-    static recalcPolarMarginWithScopedData(modelInstance: ModelInstance, designerConfig: DesignerConfig, config: MdtChartsConfig, legendBlockModel: LegendBlockModel, dataScope: DataScope, options: PolarOptionsModel): void;
     static recalcMarginByVerticalAxisLabel(modelInstance: ModelInstance, config: MdtChartsConfig, designerConfig: DesignerConfig, dataScope: DataScope): void;
     private static getHorizontalMarginByAxisLabels;
     private static recalcVerticalMarginByAxisLabelHeight;
@@ -15,6 +14,5 @@ export declare class MarginModel {
     private static recalcMarginWithLegend;
     private static getLegendItemsContent;
     static appendToGlobalMarginValuesLegendMargin(canvasModel: CanvasModel, position: Orient, legendBlockModel: LegendBlockModel): void;
-    private static clearMarginByLegendBlockPosition;
     private static recalcMarginByTitle;
 }

package/lib/model/marginModel.js

@@ -3,7 +3,7 @@ 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";
+import { keyAxisLabelHorizontalLog, keyAxisLabelVerticalLog } from "./featuresModel/scaleModel/scaleAxisRecalcer";
 export const AXIS_HORIZONTAL_LABEL_PADDING = 15;
 export const AXIS_VERTICAL_LABEL_PADDING = 10;
 export class MarginModel {
@@ -24,28 +24,15 @@ 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);
             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));
+            if (axisConfig === 'rotated') {
+                modelInstance.canvasModel.decreaseMarginSide(marginOrient, axisLabelSize.height);
+                modelInstance.canvasModel.increaseMarginSide(marginOrient, axisLabelSize.width, keyAxisLabelVerticalLog);
+            }
         }
     }
     static getHorizontalMarginByAxisLabels(labelsMaxWidth, axis, data, options) {
@@ -64,7 +51,7 @@ export class MarginModel {
         const valueAxisOrient = AxisModel.getAxisOrient(AxisType.Value, orientation, axis.value.position);
         if ((keyAxisOrient === 'bottom' || keyAxisOrient === 'top')) {
             if (axis.key.visibility)
-                canvasModel.increaseMarginSide(keyAxisOrient, labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING);
+                canvasModel.increaseMarginSide(keyAxisOrient, labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING, keyAxisLabelVerticalLog);
         }
         else if (axis.value.visibility)
             canvasModel.increaseMarginSide(valueAxisOrient, labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING);
@@ -73,7 +60,7 @@ export class MarginModel {
         const keyAxisOrient = AxisModel.getAxisOrient(AxisType.Key, orientation, axis.key.position);
         const valueAxisOrient = AxisModel.getAxisOrient(AxisType.Value, orientation, axis.value.position);
         if ((keyAxisOrient === 'left' || keyAxisOrient === 'right') && isShow && axis.key.visibility) {
-            canvasModel.increaseMarginSide(keyAxisOrient, labelSize.width + AXIS_VERTICAL_LABEL_PADDING);
+            canvasModel.increaseMarginSide(keyAxisOrient, labelSize.width + AXIS_VERTICAL_LABEL_PADDING, keyAxisLabelHorizontalLog);
         }
         else if ((valueAxisOrient === 'left' || valueAxisOrient === 'right') && axis.value.visibility) {
             canvasModel.increaseMarginSide(valueAxisOrient, labelSize.width + AXIS_VERTICAL_LABEL_PADDING);
@@ -117,15 +104,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/canvasModel/canvasModel.d.ts

@@ -1,11 +1,13 @@
 import { Size } from "../../../config/config";
 import { BlockMargin } from "../../model";
 import { LegendCanvasModelInstance } from "./legendCanvasModel";
+import { MarginModelService } from "./marginModelService";
 import { TitleCanvasModel } from "./titleCanvas";
-declare type MarginSide = keyof BlockMargin;
+export declare type MarginSide = keyof BlockMargin;
 export declare class CanvasModel {
     titleCanvas: TitleCanvasModel;
     legendCanvas: LegendCanvasModelInstance;
+    marginService: MarginModelService;
     private blockSize;
     private margin;
     constructor();
@@ -13,12 +15,11 @@ export declare class CanvasModel {
     getMargin(): BlockMargin;
     getMarginSide(side: MarginSide): number;
     setMarginSide(side: MarginSide, size: number): void;
-    increaseMarginSide(side: MarginSide, byValue: number): void;
-    descreaseMarginSide(side: MarginSide, byValue: number): void;
+    increaseMarginSide(side: MarginSide, byValue: number, key?: string): void;
+    decreaseMarginSide(side: MarginSide, byValue: number): void;
     roundMargin(): void;
     initBlockSize(blockSize: Size): void;
     getBlockSize(): Size;
     getChartBlockWidth(): number;
     getChartBlockHeight(): number;
 }
-export {};

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

@@ -1,9 +1,11 @@
 import { LegendCanvasModelInstance } from "./legendCanvasModel";
+import { MarginModelService } from "./marginModelService";
 import { TitleCanvasModel } from "./titleCanvas";
 export class CanvasModel {
     constructor() {
         this.titleCanvas = new TitleCanvasModel();
         this.legendCanvas = new LegendCanvasModelInstance();
+        this.marginService = new MarginModelService();
     }
     initMargin(margin) {
         this.margin = margin;
@@ -17,10 +19,12 @@ export class CanvasModel {
     setMarginSide(side, size) {
         this.margin[side] = size;
     }
-    increaseMarginSide(side, byValue) {
+    increaseMarginSide(side, byValue, key) {
         this.margin[side] += byValue;
+        if (key)
+            this.marginService.appendLog(key, side, byValue);
     }
-    descreaseMarginSide(side, byValue) {
+    decreaseMarginSide(side, byValue) {
         this.margin[side] -= byValue;
     }
     roundMargin() {

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

@@ -0,0 +1,11 @@
+import { MarginSide } from "./canvasModel";
+export interface MarginLogData {
+    side: MarginSide;
+    byValue: number;
+}
+export declare class MarginModelService {
+    private log;
+    appendLog(key: string, side: MarginSide, byValue: number): void;
+    getDataByKey(key: string): MarginLogData;
+    private findLogByKey;
+}

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

@@ -0,0 +1,26 @@
+export class MarginModelService {
+    constructor() {
+        this.log = [];
+    }
+    appendLog(key, side, byValue) {
+        const log = this.findLogByKey(key);
+        if (log) {
+            log.data = { side, byValue };
+            return;
+        }
+        this.log.push({
+            key,
+            data: {
+                side,
+                byValue
+            }
+        });
+    }
+    getDataByKey(key) {
+        var _a;
+        return (_a = this.findLogByKey(key)) === null || _a === void 0 ? void 0 : _a.data;
+    }
+    findLogByKey(key) {
+        return this.log.find(l => l.key === key);
+    }
+}

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;
+    }
+}