mdt-charts 1.10.2 → 1.12.0

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

@@ -1,8 +1,6 @@
 import { ModelHelper } from "../../modelHelper";
-import { TitleModel } from "../titleModel";
+import { PolarModel } from "../../notations/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')
@@ -15,9 +13,8 @@ export class LegendModel {
             return size;
         }
     }
-    static getBaseLegendBlockModel(notation) {
+    static getBaseLegendBlockModel(notation, canvasModel) {
         const mt = 20, mb = 20, ml = 20, mr = 20;
-        const titleModelTemplate = TitleModel.getTitleModel();
         return {
             coordinate: {
                 left: {
@@ -32,25 +29,25 @@ export class LegendModel {
                 },
                 right: {
                     size: 0,
-                    margin: { top: titleModelTemplate.pad + titleModelTemplate.margin.top + titleModelTemplate.size, bottom: mb, left: 0, right: mr },
+                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 0, right: mr },
                     pad: 0
                 },
                 top: {
                     size: 0,
                     margin: { top: 20, bottom: 0, left: 20, right: 20 },
-                    pad: titleModelTemplate.pad + titleModelTemplate.margin.top + titleModelTemplate.size
+                    pad: canvasModel.titleCanvas.getAllNeededSpace()
                 }
             },
             standartTooltip: notation === 'polar' ? false : true
         };
     }
-    static getLegendModel(chartNotation, legendShow, blockSize, margin) {
+    static getLegendModel(chartNotation, legendShow, canvasModel) {
         let legendPosition = 'off';
         if (legendShow) {
             if (chartNotation === '2d' || chartNotation === 'interval')
                 legendPosition = 'top';
             else if (chartNotation === 'polar') {
-                legendPosition = blockSize.width - margin.left - margin.right < MIN_DONUT_BLOCK_SIZE ? 'bottom' : 'right';
+                legendPosition = PolarModel.getLegendPositionByBlockSize(canvasModel);
             }
         }
         return {

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

@@ -1,6 +1,13 @@
-import { OtherComponents } from "../model";
+import { OtherCommonComponents } from "../model";
 import { ElementsOptions } from "../../designer/designerConfig";
 import { ChartNotation } from "../../config/config";
+import { ModelInstance } from "../modelInstance/modelInstance";
+interface OtherComponentsModelDependencies {
+    elementsOptions: ElementsOptions;
+    title: string;
+    notation: ChartNotation;
+}
 export declare class OtherComponentsModel {
-    static getOtherComponentsModel(elementsOptions: ElementsOptions, notation: ChartNotation): OtherComponents;
+    static getOtherComponentsModel(dependencies: OtherComponentsModelDependencies, modelInstance: ModelInstance): OtherCommonComponents;
 }
+export {};

package/lib/model/featuresModel/otherComponents.js

@@ -2,11 +2,13 @@ import { LegendModel } from "./legendModel/legendModel";
 import { TitleModel } from "./titleModel";
 import { TooltipModel } from "./tooltipModel";
 export class OtherComponentsModel {
-    static getOtherComponentsModel(elementsOptions, notation) {
+    static getOtherComponentsModel(dependencies, modelInstance) {
+        const canvasModel = modelInstance.canvasModel;
+        canvasModel.titleCanvas.init(TitleModel.getTitleModel(dependencies.title));
         return {
-            legendBlock: LegendModel.getBaseLegendBlockModel(notation),
-            titleBlock: TitleModel.getTitleModel(),
-            tooltipBlock: TooltipModel.getTooltipModel(elementsOptions.tooltip)
+            legendBlock: LegendModel.getBaseLegendBlockModel(dependencies.notation, canvasModel),
+            titleBlock: canvasModel.titleCanvas.getModel(),
+            tooltipBlock: TooltipModel.getTooltipModel(dependencies.elementsOptions.tooltip)
         };
     }
 }

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

@@ -1,15 +1,16 @@
-import { BlockMargin, ScaleKeyModel, ScaleKeyType, ScaleValueModel, ScaleValueType } from "../model";
-import { AxisPosition, NumberDomain, IntervalChart, TwoDimensionalChart, TwoDimensionalOptions, Size, ChartOrientation, MdtChartsDataSource } from "../../config/config";
+import { ScaleKeyModel, ScaleKeyType, ScaleValueModel, ScaleValueType } from "../model";
+import { AxisPosition, NumberDomain, IntervalChart, TwoDimensionalChart, 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, margin: BlockMargin, blockSize: Size, charts: TwoDimensionalChart[], barCharts: TwoDimensionalChart[]): ScaleKeyModel;
-    static getScaleLinear(options: TwoDimensionalOptions, data: MdtChartsDataSource, margin: BlockMargin, blockSize: Size): ScaleValueModel;
-    static getRangePeek(scaleType: ScaleType, chartOrientation: string, margin: BlockMargin, blockSize: Size): number;
+    static getScaleKey(allowableKeys: string[], orient: ChartOrientation, canvasModel: CanvasModel, charts: TwoDimensionalChart[], barCharts: TwoDimensionalChart[]): 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: TwoDimensionalOptions): [number, number];
+    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;

package/lib/model/featuresModel/scaleModel.js

@@ -5,35 +5,35 @@ export var ScaleType;
     ScaleType[ScaleType["Value"] = 1] = "Value";
 })(ScaleType || (ScaleType = {}));
 export class ScaleModel {
-    static getScaleKey(allowableKeys, orient, margin, blockSize, charts, barCharts) {
+    static getScaleKey(allowableKeys, orient, canvasModel, charts, barCharts) {
         return {
             domain: allowableKeys,
             range: {
                 start: 0,
-                end: ScaleModel.getRangePeek(ScaleType.Key, orient, margin, blockSize)
+                end: ScaleModel.getRangePeek(ScaleType.Key, orient, canvasModel)
             },
             type: ScaleModel.getScaleKeyType(charts),
             elementsAmount: this.getElementsAmount(barCharts)
         };
     }
-    static getScaleLinear(options, data, margin, blockSize) {
+    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, margin, blockSize)
+                end: ScaleModel.getRangePeek(ScaleType.Value, options.orientation, canvasModel)
             },
             type: ScaleModel.getScaleValueType(options.charts)
         };
     }
-    static getRangePeek(scaleType, chartOrientation, margin, blockSize) {
+    static getRangePeek(scaleType, chartOrientation, canvasModel) {
         if (chartOrientation === 'vertical')
             return scaleType === ScaleType.Key
-                ? blockSize.width - margin.left - margin.right
-                : blockSize.height - margin.top - margin.bottom;
+                ? canvasModel.getChartBlockWidth()
+                : canvasModel.getChartBlockHeight();
         return scaleType === ScaleType.Key
-            ? blockSize.height - margin.top - margin.bottom
-            : blockSize.width - margin.left - margin.right;
+            ? canvasModel.getChartBlockHeight()
+            : canvasModel.getChartBlockWidth();
     }
     static getDateValueDomain(data, chart, keyAxisPosition, dataSource) {
         const minMax = ModelHelper.getMinAndMaxOfIntervalData(data, dataSource, chart);

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

@@ -1,4 +1,4 @@
 import { TitleBlockModel } from "../model";
 export declare class TitleModel {
-    static getTitleModel(): TitleBlockModel;
+    static getTitleModel(titleText: string): TitleBlockModel;
 }

package/lib/model/featuresModel/titleModel.js

@@ -1,13 +1,15 @@
 export class TitleModel {
-    static getTitleModel() {
+    static getTitleModel(titleText) {
+        const defaultPads = 20;
+        const pad = titleText ? defaultPads : 0;
         return {
             margin: {
                 bottom: 0,
-                left: 20,
-                right: 20,
-                top: 20
+                left: pad,
+                right: pad,
+                top: pad
             },
-            size: 20,
+            size: pad,
             pad: 0
         };
     }

package/lib/model/marginModel.d.ts

@@ -1,13 +1,13 @@
 import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
 import { DesignerConfig } from "../designer/designerConfig";
-import { BlockMargin, DataScope, LegendBlockModel, OtherComponents, PolarOptionsModel } from "./model";
-import { Size } from "../config/config";
+import { DataScope, LegendBlockModel, OtherCommonComponents, PolarOptionsModel } from "./model";
+import { ModelInstance } from "./modelInstance/modelInstance";
 export declare const AXIS_HORIZONTAL_LABEL_PADDING = 15;
 export declare const AXIS_VERTICAL_LABEL_PADDING = 10;
 export declare class MarginModel {
-    static getMargin(designerConfig: DesignerConfig, config: MdtChartsConfig, otherComponents: OtherComponents, data: MdtChartsDataSource): BlockMargin;
-    static recalcPolarMarginWithScopedData(margin: BlockMargin, blockSize: Size, designerConfig: DesignerConfig, config: MdtChartsConfig, legendBlockModel: LegendBlockModel, dataScope: DataScope, options: PolarOptionsModel): void;
-    static recalcMarginByVerticalAxisLabel(margin: BlockMargin, config: MdtChartsConfig, designerConfig: DesignerConfig, dataScope: DataScope): void;
+    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;
     private static recalcHorizontalMarginByAxisLabelWidth;

package/lib/model/marginModel.js

@@ -1,50 +1,51 @@
 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/polarModel";
 export const AXIS_HORIZONTAL_LABEL_PADDING = 15;
 export const AXIS_VERTICAL_LABEL_PADDING = 10;
 export class MarginModel {
-    static getMargin(designerConfig, config, otherComponents, data) {
-        const margin = Object.assign({}, designerConfig.canvas.chartBlockMargin);
-        this.recalcMarginWithLegend(margin, config, designerConfig.canvas.legendBlock.maxWidth, otherComponents.legendBlock, data);
-        this.recalcMarginByTitle(margin, otherComponents.titleBlock);
+    static initMargin(designerConfig, config, otherComponents, data, modelInstance) {
+        const canvasModel = modelInstance.canvasModel;
+        canvasModel.initMargin(Object.assign({}, designerConfig.canvas.chartBlockMargin));
+        this.recalcMarginWithLegend(modelInstance, config, designerConfig.canvas.legendBlock.maxWidth, otherComponents.legendBlock, data);
+        this.recalcMarginByTitle(canvasModel, otherComponents.titleBlock);
         if (config.options.type === '2d' || config.options.type === 'interval') {
             const labelSize = this.getHorizontalMarginByAxisLabels(designerConfig.canvas.axisLabel.maxSize.main, config.options.axis, data, config.options);
-            this.recalcVerticalMarginByAxisLabelHeight(labelSize, margin, config.options.orientation, config.options.axis);
+            this.recalcVerticalMarginByAxisLabelHeight(labelSize, canvasModel, config.options.orientation, config.options.axis);
             // Если встроенный лейбл показывает ключи, то лейблы оси ключей не показываются
             // При этом все графики должны иметь: embeddedLabels = 'key'
             // И все графики должны быть типа bar. 
             const showingFlag = config.options.type === '2d'
                 ? !TwoDimensionalModel.getChartsEmbeddedLabelsFlag(config.options.charts, config.options.orientation)
                 : true;
-            this.recalcHorizontalMarginByAxisLabelWidth(labelSize, margin, config.options.orientation, config.options.axis, showingFlag);
+            this.recalcHorizontalMarginByAxisLabelWidth(labelSize, canvasModel, config.options.orientation, config.options.axis, showingFlag);
         }
-        return margin;
     }
-    static recalcPolarMarginWithScopedData(margin, blockSize, designerConfig, config, legendBlockModel, dataScope, options) {
-        let position = LegendModel.getLegendModel(config.options.type, config.options.legend.show, config.canvas.size, margin).position;
+    static recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, legendBlockModel, dataScope, options) {
+        const canvasModel = modelInstance.canvasModel;
+        let position = canvasModel.legendCanvas.getPosition();
         if (position !== 'off') {
-            if (position === 'right' && blockSize.width - margin.left - margin.right < MIN_DONUT_BLOCK_SIZE)
-                position = 'bottom';
-            this.clearMarginByLegendBlockPosition(margin, legendBlockModel);
+            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);
-            margin[position] += legendSize + legendBlockModel.coordinate[position].margin[position];
+            canvasModel.increaseMarginSide(position, legendSize + legendBlockModel.coordinate[position].margin[position]);
             legendBlockModel.coordinate[position].size = legendSize;
             options.legend.position = position;
         }
     }
-    static recalcMarginByVerticalAxisLabel(margin, config, designerConfig, dataScope) {
+    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(margin, config.canvas.size, dataScope.allowableKeys.length);
+            const axisConfig = AxisModel.getKeyAxisLabelPosition(modelInstance.canvasModel, dataScope.allowableKeys.length);
             const marginOrient = config.options.axis.key.position === 'end' ? 'bottom' : 'top';
             if (axisConfig === 'rotated')
-                margin[marginOrient] += (axisLabelSize.width - axisLabelSize.height);
+                modelInstance.canvasModel.setMarginSide(marginOrient, modelInstance.canvasModel.getMarginSide(marginOrient) + (axisLabelSize.width - axisLabelSize.height));
         }
     }
     static getHorizontalMarginByAxisLabels(labelsMaxWidth, axis, data, options) {
@@ -58,35 +59,36 @@ export class MarginModel {
         }
         return AxisModel.getLabelSize(labelsMaxWidth, labelsTexts);
     }
-    static recalcVerticalMarginByAxisLabelHeight(labelSize, margin, orientation, axis) {
+    static recalcVerticalMarginByAxisLabelHeight(labelSize, canvasModel, orientation, axis) {
         const keyAxisOrient = AxisModel.getAxisOrient(AxisType.Key, orientation, axis.key.position);
         const valueAxisOrient = AxisModel.getAxisOrient(AxisType.Value, orientation, axis.value.position);
         if ((keyAxisOrient === 'bottom' || keyAxisOrient === 'top')) {
             if (axis.key.visibility)
-                margin[keyAxisOrient] += labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING;
-        }
-        else if (axis.value.visibility) {
-            margin[valueAxisOrient] += labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING;
+                canvasModel.increaseMarginSide(keyAxisOrient, labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING);
         }
+        else if (axis.value.visibility)
+            canvasModel.increaseMarginSide(valueAxisOrient, labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING);
     }
-    static recalcHorizontalMarginByAxisLabelWidth(labelSize, margin, orientation, axis, isShow) {
+    static recalcHorizontalMarginByAxisLabelWidth(labelSize, canvasModel, orientation, axis, isShow) {
         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) {
-            margin[keyAxisOrient] += labelSize.width + AXIS_VERTICAL_LABEL_PADDING;
+            canvasModel.increaseMarginSide(keyAxisOrient, labelSize.width + AXIS_VERTICAL_LABEL_PADDING);
         }
         else if ((valueAxisOrient === 'left' || valueAxisOrient === 'right') && axis.value.visibility) {
-            margin[valueAxisOrient] += labelSize.width + AXIS_VERTICAL_LABEL_PADDING;
+            canvasModel.increaseMarginSide(valueAxisOrient, labelSize.width + AXIS_VERTICAL_LABEL_PADDING);
         }
     }
-    static recalcMarginWithLegend(margin, config, legendMaxWidth, legendBlockModel, data) {
-        const legendPosition = LegendModel.getLegendModel(config.options.type, config.options.legend.show, config.canvas.size, margin).position;
+    static recalcMarginWithLegend(modelInstance, config, legendMaxWidth, legendBlockModel, data) {
+        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, config.canvas.size, legendBlockModel);
-            margin[legendPosition] += legendSize;
+            const legendSize = LegendModel.getLegendSize(config.options.type, legendPosition, legendItemsContent, legendMaxWidth, canvasModel.getBlockSize(), legendBlockModel);
+            canvasModel.increaseMarginSide(legendPosition, legendSize);
             if (legendSize !== 0)
-                this.appendToGlobalMarginValuesLegendMargin(margin, legendPosition, legendBlockModel);
+                this.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
             legendBlockModel.coordinate[legendPosition].size = legendSize;
         }
     }
@@ -105,22 +107,23 @@ export class MarginModel {
             return [options.chart.data.valueField1.name];
         }
     }
-    static appendToGlobalMarginValuesLegendMargin(margin, position, legendBlockModel) {
+    static appendToGlobalMarginValuesLegendMargin(canvasModel, position, legendBlockModel) {
         const legendCoordinate = legendBlockModel.coordinate;
         if (position === 'left' || position === 'right')
-            margin[position] += legendCoordinate[position].margin.left + legendCoordinate[position].margin.right;
+            canvasModel.increaseMarginSide(position, legendCoordinate[position].margin.left + legendCoordinate[position].margin.right);
         else
-            margin[position] += legendCoordinate[position].margin.top + legendCoordinate[position].margin.bottom;
+            canvasModel.increaseMarginSide(position, legendCoordinate[position].margin.top + legendCoordinate[position].margin.bottom);
     }
-    static clearMarginByLegendBlockPosition(margin, legendBlockModel) {
+    static clearMarginByLegendBlockPosition(canvasModel, legendBlockModel) {
         const legendCoordinate = legendBlockModel.coordinate;
         ['left', 'right', 'top', 'bottom'].forEach((position) => {
-            margin[position] -= legendCoordinate[position].size === 0
+            const decreaseByValue = legendCoordinate[position].size === 0
                 ? 0
                 : legendCoordinate[position].size + legendCoordinate[position].margin[position];
+            canvasModel.descreaseMarginSide(position, decreaseByValue);
         });
     }
-    static recalcMarginByTitle(margin, titleBlockModel) {
-        margin.top += titleBlockModel.margin.top + titleBlockModel.size;
+    static recalcMarginByTitle(canvasModel, titleBlockModel) {
+        canvasModel.increaseMarginSide("top", titleBlockModel.margin.top + titleBlockModel.size);
     }
 }

package/lib/model/model.d.ts

@@ -12,18 +12,17 @@ export declare type DataOptions = {
 };
 export interface Model {
     blockCanvas: BlockCanvas;
-    chartBlock: ChartBlock;
+    chartBlock: ChartBlockModel;
     options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel;
-    otherComponents: OtherComponents;
+    otherComponents: OtherCommonComponents;
     dataSettings: DataSettings;
-    chartSettings: ChartElementsSettings;
     transitions?: Transitions;
 }
 export interface BlockCanvas {
     size: Size;
     cssClass: string;
 }
-export interface ChartBlock {
+export interface ChartBlockModel {
     margin: BlockMargin;
 }
 export interface BlockMargin {
@@ -46,10 +45,12 @@ export interface TwoDimensionalOptionsModel extends OptionsModel {
     charts: TwoDimensionalChartModel[];
     additionalElements: AdditionalElementsOptions;
     orient: ChartOrientation;
+    chartSettings: TwoDimChartElementsSettings;
 }
 export interface PolarOptionsModel extends OptionsModel {
     type: "polar";
     charts: PolarChartModel[];
+    chartCanvas: DonutChartSettings;
 }
 export interface IntervalOptionsModel extends OptionsModel {
     type: "interval";
@@ -58,6 +59,7 @@ export interface IntervalOptionsModel extends OptionsModel {
     charts: IntervalChartModel[];
     additionalElements: AdditionalElementsOptions;
     orient: ChartOrientation;
+    chartSettings: TwoDimChartElementsSettings;
 }
 export interface ILegendModel {
     position: LegendPosition;
@@ -125,6 +127,23 @@ export interface GridLineFlag {
     key: boolean;
     value: boolean;
 }
+export interface TwoDimChartElementsSettings {
+    bar: BarChartSettings;
+}
+export interface BarChartSettings {
+    groupMaxDistance: number;
+    groupMinDistance: number;
+    barDistance: number;
+    maxBarWidth: number;
+    minBarWidth: number;
+}
+export interface DonutChartSettings extends Omit<DonutOptionsCanvas, "aggregatorPad"> {
+    aggregator: DonutChartAggreagorModel;
+}
+export interface DonutChartAggreagorModel {
+    margin: number;
+    text: string;
+}
 interface ChartModel {
     tooltip: TooltipModel;
     cssClasses: string[];
@@ -181,20 +200,7 @@ export interface DataScope {
 export interface DataFormat {
     formatters: Formatter;
 }
-export interface ChartElementsSettings {
-    bar: BarChartSettings;
-    donut: DonutChartSettings;
-}
-export interface BarChartSettings {
-    groupMaxDistance: number;
-    groupMinDistance: number;
-    barDistance: number;
-    maxBarWidth: number;
-    minBarWidth: number;
-}
-export interface DonutChartSettings extends DonutOptionsCanvas {
-}
-export interface OtherComponents {
+export interface OtherCommonComponents {
     legendBlock: LegendBlockModel;
     titleBlock: TitleBlockModel;
     tooltipBlock: TooltipSettings;

package/lib/model/modelBuilder.js

@@ -1,10 +1,11 @@
 import { MarginModel } from './marginModel';
 import { TwoDimensionalModel } from './notations/twoDimensionalModel';
 import { PolarModel } from './notations/polarModel';
-import { DataManagerModel } from './dataManagerModel';
+import { DataManagerModel } from './dataManagerModel/dataManagerModel';
 import { IntervalModel } from './notations/intervalModel';
 import { OtherComponentsModel } from './featuresModel/otherComponents';
 import { ConfigValidator } from './configsValidator/configValidator';
+import { ModelInstance } from './modelInstance/modelInstance';
 export var AxisType;
 (function (AxisType) {
     AxisType[AxisType["Key"] = 0] = "Key";
@@ -16,27 +17,29 @@ export const CLASSES = {
     legendColor: 'legend-circle',
     legendItem: 'legend-item',
 };
-function getBlockCanvas(config) {
-    const size = ConfigValidator.validateCanvasSize(config.canvas.size) ? Object.assign({}, config.canvas.size) : { width: 0, height: 0 };
+function getBlockCanvas(config, modelInstance) {
+    const emptyBlockParams = { width: 0, height: 0 };
+    const size = ConfigValidator.validateCanvasSize(modelInstance.canvasModel.getBlockSize()) ? Object.assign({}, modelInstance.canvasModel.getBlockSize()) : emptyBlockParams;
     return {
         size,
         cssClass: config.canvas.class
     };
 }
-function getChartBlock(margin) {
+function getChartBlockModel(modelInstance) {
     return {
-        margin
+        margin: modelInstance.canvasModel.getMargin()
     };
 }
-function getOptions(config, designerConfig, margin, dataScope, data) {
+function getOptions(config, designerConfig, modelInstance, dataScope, data) {
+    //TODO: migrate to polymorphism
     if (config.options.type === '2d') {
-        return TwoDimensionalModel.getOptions(config, designerConfig, margin, dataScope, data);
+        return TwoDimensionalModel.getOptions(config.options, designerConfig, dataScope, data, modelInstance);
     }
     else if (config.options.type === 'polar') {
-        return PolarModel.getOptions(config, data, margin, designerConfig);
+        return PolarModel.getOptions(config.options, data, designerConfig, modelInstance);
     }
     else if (config.options.type === 'interval') {
-        return IntervalModel.getOptions(config, designerConfig, margin, dataScope, data);
+        return IntervalModel.getOptions(config, designerConfig, modelInstance.canvasModel.getMargin(), dataScope, data, modelInstance);
     }
 }
 function getDataSettings(dataScope, designerConfig) {
@@ -45,12 +48,6 @@ function getDataSettings(dataScope, designerConfig) {
         format: getDataFormat(designerConfig)
     };
 }
-function getChartSettings(barSettings, donutSettings) {
-    return {
-        bar: Object.assign({}, barSettings),
-        donut: Object.assign({}, donutSettings)
-    };
-}
 function getDataFormat(designerConfig) {
     return {
         formatters: designerConfig.dataFormat.formatters
@@ -59,45 +56,37 @@ function getDataFormat(designerConfig) {
 function getTransitions(designerConfig) {
     return designerConfig.transitions;
 }
-function roundMargin(margin) {
-    margin.top = Math.ceil(margin.top);
-    margin.bottom = Math.ceil(margin.bottom);
-    margin.left = Math.ceil(margin.left);
-    margin.right = Math.ceil(margin.right);
-}
 export function assembleModel(config, data, designerConfig) {
+    const modelInstance = ModelInstance.create(config);
     if (!data || Object.keys(data).length === 0)
         return {
-            blockCanvas: getBlockCanvas(config),
+            blockCanvas: getBlockCanvas(config, modelInstance),
             chartBlock: null,
             otherComponents: null,
             options: null,
-            dataSettings: null,
-            chartSettings: null
+            dataSettings: null
         };
     resetFalsyValues(data, config.options.data.keyField.name);
-    const otherComponents = OtherComponentsModel.getOtherComponentsModel(designerConfig.elementsOptions, config.options.type);
-    const margin = MarginModel.getMargin(designerConfig, config, otherComponents, data);
-    const dataScope = DataManagerModel.getDataScope(config, margin, data, designerConfig, otherComponents.legendBlock);
-    const preparedData = DataManagerModel.getPreparedData(data, dataScope.allowableKeys, config);
+    const otherComponents = OtherComponentsModel.getOtherComponentsModel({ elementsOptions: designerConfig.elementsOptions, notation: config.options.type, title: config.options.title }, modelInstance);
+    MarginModel.initMargin(designerConfig, config, otherComponents, data, modelInstance);
+    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(margin, config, designerConfig, dataScope);
-    const blockCanvas = getBlockCanvas(config);
-    const chartBlock = getChartBlock(margin);
-    const options = getOptions(config, designerConfig, margin, dataScope, preparedData);
-    const dataSettings = getDataSettings(dataScope, designerConfig);
-    const chartSettings = getChartSettings(designerConfig.canvas.chartOptions.bar, designerConfig.canvas.chartOptions.donut);
+        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 dataSettings = getDataSettings(modelInstance.dataModel.getScope(), designerConfig);
     const transitions = getTransitions(designerConfig);
     if (options.type === 'polar')
-        MarginModel.recalcPolarMarginWithScopedData(margin, config.canvas.size, designerConfig, config, otherComponents.legendBlock, dataScope, options);
-    roundMargin(margin);
+        MarginModel.recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, otherComponents.legendBlock, modelInstance.dataModel.getScope(), options);
+    modelInstance.canvasModel.roundMargin();
     return {
         blockCanvas,
         chartBlock,
         otherComponents,
         options,
         dataSettings,
-        chartSettings,
         transitions
     };
 }

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

@@ -0,0 +1,24 @@
+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();
+    initMargin(margin: BlockMargin): void;
+    getMargin(): BlockMargin;
+    getMarginSide(side: MarginSide): number;
+    setMarginSide(side: MarginSide, size: number): void;
+    increaseMarginSide(side: MarginSide, byValue: number): void;
+    descreaseMarginSide(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

@@ -0,0 +1,44 @@
+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;
+    }
+    getMargin() {
+        return this.margin;
+    }
+    getMarginSide(side) {
+        return this.margin[side];
+    }
+    setMarginSide(side, size) {
+        this.margin[side] = size;
+    }
+    increaseMarginSide(side, byValue) {
+        this.margin[side] += byValue;
+    }
+    descreaseMarginSide(side, byValue) {
+        this.margin[side] -= byValue;
+    }
+    roundMargin() {
+        this.margin.top = Math.ceil(this.margin.top);
+        this.margin.bottom = Math.ceil(this.margin.bottom);
+        this.margin.left = Math.ceil(this.margin.left);
+        this.margin.right = Math.ceil(this.margin.right);
+    }
+    initBlockSize(blockSize) {
+        this.blockSize = blockSize;
+    }
+    getBlockSize() {
+        return this.blockSize;
+    }
+    getChartBlockWidth() {
+        return this.blockSize.width - this.margin.left - this.margin.right;
+    }
+    getChartBlockHeight() {
+        return this.blockSize.height - this.margin.top - this.margin.bottom;
+    }
+}