mdt-charts 1.10.3 → 1.12.1

package/lib/model/featuresModel/axisModel.js

@@ -1,34 +1,37 @@
 import { ModelHelper } from "../modelHelper";
 import { AxisType, CLASSES } from "../modelBuilder";
-import { DataManagerModel } from "../dataManagerModel";
+import { DataManagerModel } from "../dataManagerModel/dataManagerModel";
 import { TwoDimensionalModel } from "../notations/twoDimensionalModel";
+import { AxisModelService } from "./axisModelService";
 export class AxisModel {
-    static getKeyAxis(charts, data, dataOptions, orient, axisConfig, labelConfig, margin, blockSize, tooltipSettings) {
+    static getKeyAxis(options, data, labelConfig, canvasModel, tooltipSettings) {
+        const { charts, orientation, data: dataOptions } = options;
+        const axisConfig = options.axis.key;
         return {
             type: 'key',
-            orient: AxisModel.getAxisOrient(AxisType.Key, orient, axisConfig.position),
+            orient: AxisModel.getAxisOrient(AxisType.Key, orientation, axisConfig.position),
             translate: {
-                translateX: AxisModel.getAxisTranslateX(AxisType.Key, orient, axisConfig.position, margin, blockSize.width),
-                translateY: AxisModel.getAxisTranslateY(AxisType.Key, orient, axisConfig.position, margin, blockSize.height)
+                translateX: AxisModel.getAxisTranslateX(AxisType.Key, orientation, axisConfig.position, canvasModel),
+                translateY: AxisModel.getAxisTranslateY(AxisType.Key, orientation, axisConfig.position, canvasModel)
             },
             cssClass: 'key-axis',
             ticks: axisConfig.ticks,
             labels: {
                 maxSize: AxisModel.getLabelSize(labelConfig.maxSize.main, data[dataOptions.dataSource].map(d => d[dataOptions.keyField.name])).width,
-                position: AxisModel.getKeyAxisLabelPosition(margin, blockSize, DataManagerModel.getDataValuesByKeyField(data, dataOptions.dataSource, dataOptions.keyField.name).length),
-                visible: !TwoDimensionalModel.getChartsEmbeddedLabelsFlag(charts, orient),
+                position: AxisModel.getKeyAxisLabelPosition(canvasModel, DataManagerModel.getDataValuesByKeyField(data, dataOptions.dataSource, dataOptions.keyField.name).length, axisConfig),
+                visible: !TwoDimensionalModel.getChartsEmbeddedLabelsFlag(charts, orientation),
                 defaultTooltip: tooltipSettings.position === 'fixed'
             },
             visibility: axisConfig.visibility
         };
     }
-    static getValueAxis(orient, axisConfig, labelConfig, margin, blockSize) {
+    static getValueAxis(orient, axisConfig, labelConfig, canvasModel) {
         return {
             type: 'value',
             orient: AxisModel.getAxisOrient(AxisType.Value, orient, axisConfig.position),
             translate: {
-                translateX: AxisModel.getAxisTranslateX(AxisType.Value, orient, axisConfig.position, margin, blockSize.width),
-                translateY: AxisModel.getAxisTranslateY(AxisType.Value, orient, axisConfig.position, margin, blockSize.height)
+                translateX: AxisModel.getAxisTranslateX(AxisType.Value, orient, axisConfig.position, canvasModel),
+                translateY: AxisModel.getAxisTranslateY(AxisType.Value, orient, axisConfig.position, canvasModel)
             },
             cssClass: 'value-axis',
             ticks: axisConfig.ticks,
@@ -41,12 +44,12 @@ export class AxisModel {
             visibility: axisConfig.visibility
         };
     }
-    static getAxisLength(chartOrientation, margin, blockSize) {
+    static getAxisLength(chartOrientation, canvasModel) {
         if (chartOrientation === 'horizontal') {
-            return blockSize.height - margin.top - margin.bottom;
+            return canvasModel.getChartBlockHeight();
         }
         else {
-            return blockSize.width - margin.left - margin.right;
+            return canvasModel.getChartBlockWidth();
         }
     }
     static getAxisOrient(axisType, chartOrientation, axisPosition) {
@@ -59,27 +62,25 @@ export class AxisModel {
             return axisType === AxisType.Key ? 'left' : 'top';
         return axisType === AxisType.Key ? 'right' : 'bottom';
     }
-    static getAxisTranslateX(axisType, chartOrientation, axisPosition, margin, blockWidth) {
+    static getAxisTranslateX(axisType, chartOrientation, axisPosition, canvasModel) {
         const orient = AxisModel.getAxisOrient(axisType, chartOrientation, axisPosition);
         if (orient === 'top' || orient === 'left')
-            return margin.left;
+            return canvasModel.getMarginSide("left");
         else if (orient === 'bottom')
-            return margin.left;
-        return blockWidth - margin.right;
+            return canvasModel.getMarginSide("left");
+        return canvasModel.getBlockSize().width - canvasModel.getMarginSide("right");
     }
-    static getAxisTranslateY(axisType, chartOrientation, axisPosition, margin, blockHeight) {
+    static getAxisTranslateY(axisType, chartOrientation, axisPosition, canvasModel) {
         const orient = AxisModel.getAxisOrient(axisType, chartOrientation, axisPosition);
         if (orient === 'top' || orient === 'left')
-            return margin.top;
+            return canvasModel.getMarginSide("top");
         else if (orient === 'bottom')
-            return blockHeight - margin.bottom;
-        return margin.top;
+            return canvasModel.getBlockSize().height - canvasModel.getMarginSide("bottom");
+        return canvasModel.getMarginSide("top");
     }
-    static getKeyAxisLabelPosition(margin, blockSize, scopedDataLength) {
-        const minBandSize = 50;
-        if ((blockSize.width - margin.left - margin.right) / scopedDataLength < minBandSize)
-            return 'rotated';
-        return 'straight';
+    static getKeyAxisLabelPosition(canvasModel, scopedDataLength, axisConfig) {
+        var _a;
+        return this.service.getKeyAxisLabelPosition(canvasModel.getChartBlockWidth(), scopedDataLength, (_a = axisConfig === null || axisConfig === void 0 ? void 0 : axisConfig.labels) === null || _a === void 0 ? void 0 : _a.position);
     }
     static getLabelSize(labelMaxWidth, labelTexts) {
         const labelSize = {
@@ -109,3 +110,4 @@ export class AxisModel {
         return labelSize;
     }
 }
+AxisModel.service = new AxisModelService();

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

@@ -0,0 +1,4 @@
+import { AxisLabelPosition } from "../../config/config";
+export declare class AxisModelService {
+    getKeyAxisLabelPosition(chartBlockWidth: number, scopedDataLength: number, positionFromConfig?: AxisLabelPosition): AxisLabelPosition;
+}

package/lib/model/featuresModel/axisModelService.js

@@ -0,0 +1,11 @@
+export class AxisModelService {
+    getKeyAxisLabelPosition(chartBlockWidth, scopedDataLength, positionFromConfig) {
+        if (positionFromConfig === "rotated" || positionFromConfig === "straight") {
+            return positionFromConfig;
+        }
+        const minBandSize = 50;
+        if (chartBlockWidth / scopedDataLength < minBandSize)
+            return 'rotated';
+        return 'straight';
+    }
+}

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

@@ -1,7 +1,9 @@
+import { DataLegendParams } from "../../dataManagerModel/dataManagerModel";
 import { LegendPosition } from "../../model";
 export declare type LegendItemsDirection = 'row' | 'column';
 export declare class LegendCanvasModel {
-    static getLegendHeight(texts: string[], blockWidth: number, marginLeft: number, marginRight: number, itemsPosition: LegendItemsDirection, legendPosition: LegendPosition): number;
+    static getLegendHeight(texts: string[], chartBlockWidth: number, itemsDirection: LegendItemsDirection, legendPosition: LegendPosition): number;
     static getLegendItemWidth(text: string): number;
-    static findElementsAmountByLegendSize(texts: string[], position: LegendPosition, legendBlockWidth: number, legendBlockHeight: number): number;
+    static findElementsAmountByLegendSize(texts: string[], position: LegendPosition, legendBlockWidth: number, legendBlockHeight: number): DataLegendParams;
+    private static getLegendWrapperEl;
 }

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

@@ -1,22 +1,18 @@
 import { CLASSES } from "../../modelBuilder";
-import { LegendModel } from "./legendModel";
 export class LegendCanvasModel {
-    static getLegendHeight(texts, blockWidth, marginLeft, marginRight, itemsPosition, legendPosition) {
-        const legendWrapper = document.createElement('div');
-        legendWrapper.style.opacity = '0';
-        legendWrapper.style.display = 'flex';
-        if (itemsPosition === 'column')
-            legendWrapper.style.flexDirection = 'column';
-        legendWrapper.style.position = 'absolute';
-        legendWrapper.style.width = blockWidth - marginLeft - marginRight + 'px';
+    static getLegendHeight(texts, chartBlockWidth, itemsDirection, legendPosition) {
+        const legendWrapper = this.getLegendWrapperEl(chartBlockWidth, itemsDirection);
         texts.forEach(text => {
             const itemWrapper = document.createElement('div');
             const colorBlock = document.createElement('span');
             const textBlock = document.createElement('span');
-            itemWrapper.classList.add(LegendModel.getLegendItemClass(itemsPosition));
-            if (itemsPosition === 'column') {
-                itemWrapper.style.whiteSpace = 'nowrap';
-                itemWrapper.classList.add(LegendModel.getMarginClass(legendPosition));
+            itemWrapper.classList.add("legend-item");
+            if (legendPosition === 'bottom') {
+                itemWrapper.classList.add('legend-item-inline');
+                textBlock.classList.add('legend-label-nowrap');
+            }
+            else {
+                itemWrapper.classList.add('legend-item-row');
             }
             colorBlock.classList.add(CLASSES.legendColor);
             textBlock.classList.add(CLASSES.legendLabel);
@@ -27,7 +23,7 @@ export class LegendCanvasModel {
         document.body.append(legendWrapper);
         const height = legendWrapper.offsetHeight;
         legendWrapper.remove();
-        return height;
+        return height + 1;
     }
     static getLegendItemWidth(text) {
         const itemWrapper = document.createElement('div');
@@ -48,39 +44,56 @@ export class LegendCanvasModel {
         return sumWidth;
     }
     static findElementsAmountByLegendSize(texts, position, legendBlockWidth, legendBlockHeight) {
-        const legendWrapper = document.createElement('div');
-        legendWrapper.style.opacity = '0';
-        legendWrapper.style.display = 'flex';
-        legendWrapper.style.flexDirection = 'column';
-        legendWrapper.style.position = 'absolute';
-        legendWrapper.style.width = legendBlockWidth + 'px';
+        const legendWrapper = this.getLegendWrapperEl(legendBlockWidth, position === "right" ? "column" : "row");
         document.body.append(legendWrapper);
         let amount = 0;
         for (let i = 0; i < texts.length; i++) {
             const itemWrapper = document.createElement('div');
             const colorBlock = document.createElement('span');
             const textBlock = document.createElement('span');
-            itemWrapper.classList.add('legend-item-row');
-            if (position === 'bottom')
-                textBlock.classList.add('legend-label-nowrap', 'mt-10');
-            else
-                itemWrapper.classList.add('mt-15');
+            itemWrapper.classList.add("legend-item");
+            if (position === 'bottom') {
+                itemWrapper.classList.add('legend-item-inline');
+                textBlock.classList.add('legend-label-nowrap');
+            }
+            else {
+                itemWrapper.classList.add('legend-item-row');
+            }
             colorBlock.classList.add(CLASSES.legendColor);
             textBlock.classList.add(CLASSES.legendLabel);
             textBlock.textContent = texts[i];
             itemWrapper.append(colorBlock, textBlock);
             legendWrapper.append(itemWrapper);
+            amount++;
             if (legendWrapper.offsetHeight > legendBlockHeight) {
                 itemWrapper.remove();
                 if (legendBlockHeight - legendWrapper.offsetHeight >= 15 && position !== 'bottom')
-                    amount = i;
+                    amount = amount; //TODO: remove
                 else
-                    amount = i - 1;
+                    amount -= 1;
                 break;
             }
-            amount++;
         }
+        const size = {
+            width: legendWrapper.offsetWidth,
+            height: legendWrapper.offsetHeight
+        };
         legendWrapper.remove();
-        return amount < 0 ? 0 : amount;
+        return {
+            amount: amount < 0 ? 0 : amount,
+            size
+        };
+    }
+    static getLegendWrapperEl(legendBlockWidth, itemsDirection) {
+        const legendWrapper = document.createElement('div');
+        legendWrapper.style.opacity = '0';
+        legendWrapper.style.position = 'absolute';
+        legendWrapper.style.display = "flex";
+        if (itemsDirection === "column")
+            legendWrapper.classList.add("legend-block-column");
+        else
+            legendWrapper.classList.add("legend-block-row", "legend-wrapper-with-wrap");
+        legendWrapper.style.maxWidth = legendBlockWidth + 'px';
+        return legendWrapper;
     }
 }

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

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

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

@@ -1,23 +1,21 @@
 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')
             return this.getLegendWidth(texts, legendMaxWidth);
+        //TODO: rm duplicate
         if (chartNotation === '2d' || chartNotation === 'interval') {
-            return LegendCanvasModel.getLegendHeight(texts, blockSize.width, legendBlockModel.coordinate[position].margin.left, legendBlockModel.coordinate[position].margin.right, 'row', position);
+            return LegendCanvasModel.getLegendHeight(texts, blockSize.width - legendBlockModel.coordinate[position].margin.left - legendBlockModel.coordinate[position].margin.right, 'row', position);
         }
         else if (chartNotation === 'polar') {
-            const size = LegendCanvasModel.getLegendHeight(texts, blockSize.width, legendBlockModel.coordinate[position].margin.left, legendBlockModel.coordinate[position].margin.right, 'column', position);
+            const size = LegendCanvasModel.getLegendHeight(texts, blockSize.width - legendBlockModel.coordinate[position].margin.left - legendBlockModel.coordinate[position].margin.right, 'row', position);
             return size;
         }
     }
-    static getBaseLegendBlockModel(notation) {
+    static getBaseLegendBlockModel(notation, canvasModel) {
         const mt = 20, mb = 20, ml = 20, mr = 20;
-        const titleModelTemplate = TitleModel.getTitleModel();
         return {
             coordinate: {
                 left: {
@@ -27,31 +25,33 @@ export class LegendModel {
                 },
                 bottom: {
                     size: 0,
-                    margin: { top: 0, bottom: 20, left: 20, right: 20 },
+                    margin: { top: 0, bottom: 20, left: 0, right: 0 },
                     pad: 0
                 },
                 right: {
                     size: 0,
-                    margin: { top: titleModelTemplate.pad + titleModelTemplate.margin.top + titleModelTemplate.size, bottom: mb, left: 0, right: mr },
+                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 10, right: 0 },
                     pad: 0
                 },
                 top: {
                     size: 0,
-                    margin: { top: 20, bottom: 0, left: 20, right: 20 },
-                    pad: titleModelTemplate.pad + titleModelTemplate.margin.top + titleModelTemplate.size
+                    margin: { top: 10, bottom: 10, left: 20, right: 20 },
+                    pad: canvasModel.titleCanvas.getAllNeededSpace()
                 }
             },
             standartTooltip: notation === 'polar' ? false : true
         };
     }
-    static getLegendModel(chartNotation, legendShow, blockSize, margin) {
+    static getLegendModel(chartNotation, legendShow, canvasModel) {
+        if (!legendShow)
+            return {
+                position: 'off'
+            };
         let legendPosition = 'off';
-        if (legendShow) {
-            if (chartNotation === '2d' || chartNotation === 'interval')
-                legendPosition = 'top';
-            else if (chartNotation === 'polar') {
-                legendPosition = blockSize.width - margin.left - margin.right < MIN_DONUT_BLOCK_SIZE ? 'bottom' : 'right';
-            }
+        if (chartNotation === '2d' || chartNotation === 'interval')
+            legendPosition = 'top';
+        else if (chartNotation === 'polar') {
+            legendPosition = PolarModel.getLegendPositionByBlockSize(canvasModel);
         }
         return {
             position: legendPosition
@@ -60,9 +60,6 @@ export class LegendModel {
     static getLegendItemClass(itemsPosition) {
         return itemsPosition === 'column' ? 'legend-item-row' : 'legend-item-inline';
     }
-    static getMarginClass(legendPosition) {
-        return legendPosition === 'right' ? 'mt-15' : 'mt-10';
-    }
     static getLegendWidth(texts, legendMaxWidth) {
         let longestText = '';
         let biggestScore = 0;

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

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

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

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

package/lib/model/featuresModel/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
+                bottom: 10,
+                left: pad,
+                right: pad,
+                top: pad
             },
-            size: 20,
+            size: pad,
             pad: 0
         };
     }

package/lib/model/marginModel.d.ts

@@ -1,19 +1,20 @@
 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, Orient, OtherCommonComponents, PolarOptionsModel } from "./model";
+import { ModelInstance } from "./modelInstance/modelInstance";
+import { CanvasModel } from "./modelInstance/canvasModel/canvasModel";
 export declare const AXIS_HORIZONTAL_LABEL_PADDING = 15;
 export declare const AXIS_VERTICAL_LABEL_PADDING = 10;
 export declare class MarginModel {
-    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;
     private static recalcMarginWithLegend;
     private static getLegendItemsContent;
-    private static appendToGlobalMarginValuesLegendMargin;
+    static appendToGlobalMarginValuesLegendMargin(canvasModel: CanvasModel, position: Orient, legendBlockModel: LegendBlockModel): void;
     private static clearMarginByLegendBlockPosition;
     private static recalcMarginByTitle;
 }