mdt-charts 1.10.3 → 1.12.1

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, config.options.axis.key);
             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,39 @@ 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) {
+        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, 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 +110,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 + titleBlockModel.margin.bottom);
     }
 }

package/lib/model/model.d.ts

@@ -1,10 +1,9 @@
-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 = {
@@ -12,18 +11,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 +44,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 +58,7 @@ export interface IntervalOptionsModel extends OptionsModel {
     charts: IntervalChartModel[];
     additionalElements: AdditionalElementsOptions;
     orient: ChartOrientation;
+    chartSettings: TwoDimChartElementsSettings;
 }
 export interface ILegendModel {
     position: LegendPosition;
@@ -125,6 +126,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 +199,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);
+    // if (options.type === 'polar')
+    //     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;
+    }
+}

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/canvasModel/titleCanvas.d.ts

@@ -0,0 +1,9 @@
+import { TitleBlockModel } from "../../model";
+declare type TitleBlockCanvas = TitleBlockModel;
+export declare class TitleCanvasModel {
+    private model;
+    init(model: TitleBlockCanvas): void;
+    getModel(): TitleBlockModel;
+    getAllNeededSpace(): number;
+}
+export {};

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

@@ -0,0 +1,11 @@
+export class TitleCanvasModel {
+    init(model) {
+        this.model = model;
+    }
+    getModel() {
+        return this.model;
+    }
+    getAllNeededSpace() {
+        return this.model.pad + this.model.size + this.model.margin.top;
+    }
+}

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

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

@@ -0,0 +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();
+        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,8 +1,9 @@
 import { MdtChartsConfig, MdtChartsDataSource, IntervalOptions } 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): IntervalOptionsModel;
+    static getOptions(config: MdtChartsConfig, designerConfig: DesignerConfig, margin: BlockMargin, dataScope: DataScope, data: MdtChartsDataSource, modelInstance: ModelInstance): IntervalOptionsModel;
     static getAdditionalElements(options: IntervalOptions): AdditionalElementsOptions;
     private static getChartsModel;
 }