mdt-charts 1.12.11 → 1.12.15

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

@@ -0,0 +1,22 @@
+export function getScaleKeyRangePeek(chartOrientation, canvasModel) {
+    if (chartOrientation === 'vertical')
+        return canvasModel.getChartBlockWidth();
+    return canvasModel.getChartBlockHeight();
+}
+export function getScaleValueRangePeek(chartOrientation, canvasModel) {
+    if (chartOrientation === 'vertical')
+        return canvasModel.getChartBlockHeight();
+    return canvasModel.getChartBlockWidth();
+}
+export function getElementsAmountForScale(barCharts) {
+    if (barCharts.length === 0)
+        return 1;
+    let barsAmount = 0;
+    barCharts.forEach(chart => {
+        if (chart.isSegmented)
+            barsAmount += 1; // Если бар сегментированный, то все valueFields являются частями одного бара
+        else
+            barsAmount += chart.data.valueFields.length;
+    });
+    return barsAmount;
+}

package/lib/model/margin/marginModel.d.ts

@@ -0,0 +1,10 @@
+import { MdtChartsConfig, MdtChartsDataSource, MdtChartsTwoDimensionalOptions } from "../../config/config";
+import { DesignerConfig } from "../../designer/designerConfig";
+import { OtherCommonComponents } from "../model";
+import { ModelInstance } from "../modelInstance/modelInstance";
+export declare class MarginModel {
+    private twoDimModel;
+    initMargin(designerConfig: DesignerConfig, config: MdtChartsConfig, otherComponents: OtherCommonComponents, data: MdtChartsDataSource, modelInstance: ModelInstance): void;
+    recalcMarginByVerticalAxisLabel(modelInstance: ModelInstance, options: MdtChartsTwoDimensionalOptions, designerConfig: DesignerConfig): void;
+    private recalcMarginByTitle;
+}

package/lib/model/margin/marginModel.js

@@ -0,0 +1,20 @@
+import { TwoDimMarginModel } from "./twoDim/twoDimMarginModel";
+export class MarginModel {
+    constructor() {
+        this.twoDimModel = new TwoDimMarginModel();
+    }
+    initMargin(designerConfig, config, otherComponents, data, modelInstance) {
+        const canvasModel = modelInstance.canvasModel;
+        canvasModel.initMargin(Object.assign({}, designerConfig.canvas.chartBlockMargin));
+        this.recalcMarginByTitle(canvasModel);
+        if (config.options.type === '2d') {
+            this.twoDimModel.recalcMargin(designerConfig, config.options, otherComponents, data, modelInstance);
+        }
+    }
+    recalcMarginByVerticalAxisLabel(modelInstance, options, designerConfig) {
+        this.twoDimModel.recalcMarginByVerticalAxisLabel(modelInstance, options, designerConfig);
+    }
+    recalcMarginByTitle(canvasModel) {
+        canvasModel.increaseMarginSide("top", canvasModel.titleCanvas.getAllNeededSpace());
+    }
+}

package/lib/model/margin/twoDim/twoDimMarginModel.d.ts

@@ -0,0 +1,14 @@
+import { MdtChartsDataSource, MdtChartsTwoDimensionalOptions } from "../../../config/config";
+import { DesignerConfig } from "../../../designer/designerConfig";
+import { OtherCommonComponents } 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 TwoDimMarginModel {
+    private twoDimLegendModel;
+    recalcMargin(designerConfig: DesignerConfig, options: MdtChartsTwoDimensionalOptions, otherComponents: OtherCommonComponents, data: MdtChartsDataSource, modelInstance: ModelInstance): void;
+    recalcMarginByVerticalAxisLabel(modelInstance: ModelInstance, options: MdtChartsTwoDimensionalOptions, designerConfig: DesignerConfig): void;
+    private getHorizontalMarginByAxisLabels;
+    private recalcVerticalMarginByAxisLabelHeight;
+    private recalcHorizontalMarginByAxisLabelWidth;
+}

package/lib/model/margin/twoDim/twoDimMarginModel.js

@@ -0,0 +1,69 @@
+import { DataManagerModel } from "../../dataManagerModel/dataManagerModel";
+import { AxisModel } from "../../featuresModel/axisModel";
+import { TwoDimLegendModel } from "../../featuresModel/legendModel/twoDimLegendModel";
+import { keyAxisLabelHorizontalLog, keyAxisLabelVerticalLog } from "../../featuresModel/scaleModel/scaleAxisRecalcer";
+import { AxisType } from "../../modelBuilder";
+import { TwoDimensionalModel } from "../../notations/twoDimensionalModel";
+export const AXIS_HORIZONTAL_LABEL_PADDING = 15;
+export const AXIS_VERTICAL_LABEL_PADDING = 10;
+export class TwoDimMarginModel {
+    constructor() {
+        this.twoDimLegendModel = new TwoDimLegendModel();
+    }
+    recalcMargin(designerConfig, options, otherComponents, data, modelInstance) {
+        const canvasModel = modelInstance.canvasModel;
+        this.twoDimLegendModel.recalcMarginWith2DLegend(modelInstance, otherComponents.legendBlock);
+        const labelSize = this.getHorizontalMarginByAxisLabels(designerConfig.canvas.axisLabel.maxSize.main, options.axis, data, options);
+        this.recalcVerticalMarginByAxisLabelHeight(labelSize, canvasModel, options.orientation, options.axis);
+        // Если встроенный лейбл показывает ключи, то лейблы оси ключей не показываются
+        // При этом все графики должны иметь: embeddedLabels = 'key'
+        // И все графики должны быть типа bar. 
+        const showingFlag = options.type === '2d'
+            ? !TwoDimensionalModel.getChartsEmbeddedLabelsFlag(options.charts, options.orientation)
+            : true;
+        this.recalcHorizontalMarginByAxisLabelWidth(labelSize, canvasModel, options.orientation, options.axis, showingFlag);
+    }
+    recalcMarginByVerticalAxisLabel(modelInstance, options, designerConfig) {
+        if (options.orientation === 'vertical') {
+            const dataModel = modelInstance.dataModel;
+            const axisLabelSize = AxisModel.getLabelSize(designerConfig.canvas.axisLabel.maxSize.main, dataModel.getAllowableKeys());
+            const axisConfig = AxisModel.getKeyAxisLabelPosition(modelInstance.canvasModel, dataModel.getAllowableKeys().length, options.axis.key);
+            const marginOrient = options.axis.key.position === 'end' ? 'bottom' : 'top';
+            if (axisConfig === 'rotated') {
+                modelInstance.canvasModel.decreaseMarginSide(marginOrient, axisLabelSize.height);
+                modelInstance.canvasModel.increaseMarginSide(marginOrient, axisLabelSize.width, keyAxisLabelVerticalLog);
+            }
+        }
+    }
+    getHorizontalMarginByAxisLabels(labelsMaxWidth, axis, data, options) {
+        const keyAxisOrient = AxisModel.getAxisOrient(AxisType.Key, options.orientation, axis.key.position);
+        let labelsTexts;
+        if (keyAxisOrient === 'left' || keyAxisOrient === 'right') {
+            labelsTexts = DataManagerModel.getDataValuesByKeyField(data, options.data.dataSource, options.data.keyField.name);
+        }
+        else {
+            labelsTexts = ['0000'];
+        }
+        return AxisModel.getLabelSize(labelsMaxWidth, labelsTexts);
+    }
+    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)
+                canvasModel.increaseMarginSide(keyAxisOrient, labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING, keyAxisLabelVerticalLog);
+        }
+        else if (axis.value.visibility)
+            canvasModel.increaseMarginSide(valueAxisOrient, labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING);
+    }
+    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) {
+            canvasModel.increaseMarginSide(keyAxisOrient, labelSize.width + AXIS_VERTICAL_LABEL_PADDING, keyAxisLabelHorizontalLog);
+        }
+        else if ((valueAxisOrient === 'left' || valueAxisOrient === 'right') && axis.value.visibility) {
+            canvasModel.increaseMarginSide(valueAxisOrient, labelSize.width + AXIS_VERTICAL_LABEL_PADDING);
+        }
+    }
+}

package/lib/model/modelBuilder.d.ts

@@ -13,4 +13,3 @@ export declare const CLASSES: {
 };
 export declare function assembleModel(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig): Model;
 export declare function getPreparedData(model: Model, data: MdtChartsDataSource, config: MdtChartsConfig): MdtChartsDataSource;
-export declare function getUpdatedModel(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig): Model;

package/lib/model/modelBuilder.js

@@ -1,4 +1,4 @@
-import { MarginModel } from './marginModel';
+import { MarginModel } from './margin/marginModel';
 import { TwoDimensionalModel } from './notations/twoDimensionalModel';
 import { PolarModel } from './notations/polar/polarModel';
 import { DataManagerModel } from './dataManagerModel/dataManagerModel';
@@ -30,16 +30,16 @@ function getChartBlockModel(modelInstance) {
         margin: modelInstance.canvasModel.getMargin()
     };
 }
-function getOptions(config, designerConfig, modelInstance, data) {
+function getOptions(config, designerConfig, modelInstance) {
     //TODO: migrate to polymorphism
     if (config.options.type === '2d') {
-        return TwoDimensionalModel.getOptions(config.options, designerConfig, data, modelInstance);
+        return TwoDimensionalModel.getOptions(config.options, designerConfig, modelInstance);
     }
     else if (config.options.type === 'polar') {
         return PolarModel.getOptions(config.options, designerConfig, modelInstance);
     }
     else if (config.options.type === 'interval') {
-        return IntervalModel.getOptions(config, designerConfig, modelInstance.canvasModel.getMargin(), modelInstance.dataModel.getScope(), data, modelInstance);
+        return IntervalModel.getOptions(config.options, designerConfig, modelInstance);
     }
 }
 function getDataSettings(dataScope, designerConfig) {
@@ -68,15 +68,14 @@ export function assembleModel(config, data, designerConfig) {
         };
     resetFalsyValues(data, config.options.data.keyField.name);
     const otherComponents = OtherComponentsModel.getOtherComponentsModel({ elementsOptions: designerConfig.elementsOptions, title: config.options.title }, modelInstance);
-    MarginModel.initMargin(designerConfig, config, otherComponents, data, modelInstance);
+    const marginModel = new MarginModel();
+    marginModel.initMargin(designerConfig, config, otherComponents, data, modelInstance);
     DataManagerModel.initDataScope(config, data, designerConfig, otherComponents.legendBlock, modelInstance);
-    const preparedData = DataManagerModel.getPreparedData(data, modelInstance.dataModel.getAllowableKeys(), config);
-    modelInstance.dataModel.repository.initScopedFullSource(preparedData);
     if (config.options.type === '2d' && config.options.axis.key.visibility)
-        MarginModel.recalcMarginByVerticalAxisLabel(modelInstance, config, designerConfig, modelInstance.dataModel.getScope());
+        marginModel.recalcMarginByVerticalAxisLabel(modelInstance, config.options, designerConfig);
     const blockCanvas = getBlockCanvas(config, modelInstance);
     const chartBlock = getChartBlockModel(modelInstance);
-    const options = getOptions(config, designerConfig, modelInstance, preparedData);
+    const options = getOptions(config, designerConfig, modelInstance);
     const dataSettings = getDataSettings(modelInstance.dataModel.getScope(), designerConfig);
     const transitions = getTransitions(designerConfig);
     modelInstance.canvasModel.roundMargin();
@@ -111,6 +110,3 @@ export function getPreparedData(model, data, config) {
     const preparedData = DataManagerModel.getPreparedData(data, model.dataSettings.scope.allowableKeys, config);
     return preparedData;
 }
-export function getUpdatedModel(config, data, designerConfig) {
-    return assembleModel(config, data, designerConfig);
-}

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

@@ -1,10 +1,11 @@
 import { Size } from "../../../config/config";
 import { BlockMargin } from "../../model";
 import { LegendCanvasModelInstance } from "./legendCanvasModel";
-import { MarginModelService } from "./marginModelService";
+import { CanvasMarginModel, MarginSide } from "./canvasSizesModel/canvasMarginModel";
+import { MarginModelService } from "./canvasSizesModel/marginModelService";
 import { TitleCanvasModel } from "./titleCanvas";
-export declare type MarginSide = keyof BlockMargin;
-export declare class CanvasModel {
+import { CanvasSizesModel } from "./canvasSizesModel/canvasSizeModel";
+export declare class CanvasModel implements CanvasMarginModel, CanvasSizesModel {
     titleCanvas: TitleCanvasModel;
     legendCanvas: LegendCanvasModelInstance;
     marginService: MarginModelService;

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

@@ -1,5 +1,5 @@
 import { LegendCanvasModelInstance } from "./legendCanvasModel";
-import { MarginModelService } from "./marginModelService";
+import { MarginModelService } from "./canvasSizesModel/marginModelService";
 import { TitleCanvasModel } from "./titleCanvas";
 export class CanvasModel {
     constructor() {

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

@@ -0,0 +1,11 @@
+import { BlockMargin } from "../../../model";
+export declare type MarginSide = keyof BlockMargin;
+export interface CanvasMarginModel {
+    initMargin(margin: BlockMargin): void;
+    getMargin(): BlockMargin;
+    getMarginSide(side: MarginSide): number;
+    setMarginSide(side: MarginSide, size: number): void;
+    increaseMarginSide(side: MarginSide, byValue: number, key?: string): void;
+    decreaseMarginSide(side: MarginSide, byValue: number): void;
+    roundMargin(): void;
+}

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

@@ -0,0 +1,4 @@
+export interface CanvasSizesModel {
+    getChartBlockWidth(): number;
+    getChartBlockHeight(): number;
+}

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

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

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

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

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

@@ -6,6 +6,6 @@ export class TitleCanvasModel {
         return this.model;
     }
     getAllNeededSpace() {
-        return this.model.pad + this.model.size + this.model.margin.top;
+        return this.model.pad + this.model.size + this.model.margin.top + this.model.margin.bottom;
     }
 }

package/lib/model/notations/intervalModel.d.ts

@@ -1,9 +1,9 @@
-import { MdtChartsConfig, MdtChartsDataSource, MdtChartsIntervalOptions } from "../../config/config";
+import { MdtChartsIntervalOptions } from "../../config/config";
 import { DesignerConfig } from "../../designer/designerConfig";
-import { AdditionalElementsOptions, BlockMargin, DataScope, IntervalOptionsModel } from "../model";
+import { AdditionalElementsOptions, IntervalOptionsModel } from "../model";
 import { ModelInstance } from "../modelInstance/modelInstance";
 export declare class IntervalModel {
-    static getOptions(config: MdtChartsConfig, designerConfig: DesignerConfig, margin: BlockMargin, dataScope: DataScope, data: MdtChartsDataSource, modelInstance: ModelInstance): IntervalOptionsModel;
+    static getOptions(options: MdtChartsIntervalOptions, designerConfig: DesignerConfig, modelInstance: ModelInstance): IntervalOptionsModel;
     static getAdditionalElements(options: MdtChartsIntervalOptions): AdditionalElementsOptions;
     private static getChartsModel;
 }

package/lib/model/notations/intervalModel.js

@@ -2,12 +2,11 @@ import { AxisModel } from "../featuresModel/axisModel";
 import { ChartStyleModelService } from "../chartStyleModel/chartStyleModel";
 import { DataManagerModel } from "../dataManagerModel/dataManagerModel";
 import { AxisType } from "../modelBuilder";
-import { ScaleModel, ScaleType } from "../featuresModel/scaleModel/scaleModel";
 import { TwoDimensionalModel } from "./twoDimensionalModel";
 export class IntervalModel {
-    static getOptions(config, designerConfig, margin, dataScope, data, modelInstance) {
-        const options = config.options;
+    static getOptions(options, designerConfig, modelInstance) {
         const canvasModel = modelInstance.canvasModel;
+        const dataModelRep = modelInstance.dataModel.repository;
         return {
             legend: canvasModel.legendCanvas.getModel(),
             title: options.title,
@@ -15,19 +14,19 @@ export class IntervalModel {
             orient: options.orientation,
             scale: {
                 key: {
-                    domain: dataScope.allowableKeys,
+                    domain: modelInstance.dataModel.getAllowableKeys(),
                     range: {
                         start: 0,
-                        end: ScaleModel.getRangePeek(ScaleType.Key, options.orientation, canvasModel)
+                        end: 0
                     },
                     type: 'band',
                     elementsAmount: 1
                 },
                 value: {
-                    domain: ScaleModel.getDateValueDomain(data, options.chart, options.axis.key.position, options.data.dataSource),
+                    domain: [],
                     range: {
                         start: 0,
-                        end: ScaleModel.getRangePeek(ScaleType.Value, options.orientation, canvasModel)
+                        end: 0
                     },
                     type: 'datetime'
                 }
@@ -43,8 +42,8 @@ export class IntervalModel {
                     cssClass: 'key-axis',
                     ticks: options.axis.key.ticks,
                     labels: {
-                        maxSize: AxisModel.getLabelSize(designerConfig.canvas.axisLabel.maxSize.main, data[options.data.dataSource].map(d => d[options.data.keyField.name])).width,
-                        position: AxisModel.getKeyAxisLabelPosition(canvasModel, DataManagerModel.getDataValuesByKeyField(data, options.data.dataSource, options.data.keyField.name).length),
+                        maxSize: AxisModel.getLabelSize(designerConfig.canvas.axisLabel.maxSize.main, dataModelRep.getScopedRows().map(d => d[options.data.keyField.name])).width,
+                        position: AxisModel.getKeyAxisLabelPosition(canvasModel, DataManagerModel.getDataValuesByKeyField(dataModelRep.getScopedFullSource(), options.data.dataSource, options.data.keyField.name).length),
                         visible: true,
                         defaultTooltip: designerConfig.elementsOptions.tooltip.position === 'fixed'
                     },

package/lib/model/notations/polar/donut/donutAggregatorService.d.ts

@@ -9,4 +9,5 @@ export declare class DonutAggregatorService {
     getContent(aggregatorOptions: MdtChartsDonutAggregator, dataOptions: AggregatorServiceDataOptions): DonutAggregatorContent;
     private doesValueExist;
     private generateDefaultContent;
+    private getDefaultValue;
 }

package/lib/model/notations/polar/donut/donutAggregatorService.js

@@ -4,14 +4,25 @@ export class DonutAggregatorService {
         if (!(aggregatorOptions === null || aggregatorOptions === void 0 ? void 0 : aggregatorOptions.content) || !dataOptions.rows)
             return this.generateDefaultContent(dataOptions);
         const content = aggregatorOptions.content({ data: dataOptions.rows });
-        if (this.doesValueExist(content.value) && content.title)
-            return content;
+        if (!content || (!this.doesValueExist(content.value) && !content.title))
+            return this.generateDefaultContent(dataOptions);
+        if (this.doesValueExist(content.value) && content.title) {
+            return {
+                title: content.title,
+                value: content.value
+            };
+        }
         if (!content.title && this.doesValueExist(content.value))
             return {
                 value: content.value,
                 title: AGGREGATOR_DEFAULT_TITLE
             };
-        return this.generateDefaultContent(dataOptions);
+        if (!this.doesValueExist(content.value) && content.title) {
+            return {
+                value: this.getDefaultValue(dataOptions),
+                title: content.title
+            };
+        }
     }
     doesValueExist(content) {
         return content != null;
@@ -19,7 +30,11 @@ export class DonutAggregatorService {
     generateDefaultContent(dataOptions) {
         return {
             title: AGGREGATOR_DEFAULT_TITLE,
-            value: dataOptions.rows ? dataOptions.rows.reduce((acc, row) => acc + row[dataOptions.valueFieldName], 0) : 0
+            value: dataOptions.rows ? this.getDefaultValue(dataOptions) : 0
         };
     }
+    getDefaultValue(dataOptions) {
+        const totalSumOfValues = dataOptions.rows.reduce((acc, row) => acc + row[dataOptions.valueFieldName], 0);
+        return totalSumOfValues;
+    }
 }

package/lib/model/notations/twoDimensionalModel.d.ts

@@ -1,9 +1,9 @@
-import { ChartOrientation, MdtChartsDataSource, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions } from "../../config/config";
+import { ChartOrientation, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions } from "../../config/config";
 import { BarOptionsCanvas, DesignerConfig } from "../../designer/designerConfig";
 import { TwoDimensionalOptionsModel, TwoDimChartElementsSettings } from "../model";
 import { ModelInstance } from "../modelInstance/modelInstance";
 export declare class TwoDimensionalModel {
-    static getOptions(options: MdtChartsTwoDimensionalOptions, designerConfig: DesignerConfig, data: MdtChartsDataSource, modelInstance: ModelInstance): TwoDimensionalOptionsModel;
+    static getOptions(options: MdtChartsTwoDimensionalOptions, designerConfig: DesignerConfig, modelInstance: ModelInstance): TwoDimensionalOptionsModel;
     static getChartsEmbeddedLabelsFlag(charts: MdtChartsTwoDimensionalChart[], chartOrientation: ChartOrientation): boolean;
     /**
      * Сортирует список чартов в порядке: area - bar - line.

package/lib/model/notations/twoDimensionalModel.js

@@ -4,9 +4,11 @@ import { AxisModel } from "../featuresModel/axisModel";
 import { ScaleAxisRecalcer } from "../featuresModel/scaleModel/scaleAxisRecalcer";
 import { ScaleModel } from "../featuresModel/scaleModel/scaleModel";
 export class TwoDimensionalModel {
-    static getOptions(options, designerConfig, data, modelInstance) {
+    static getOptions(options, designerConfig, modelInstance) {
         const canvasModel = modelInstance.canvasModel;
-        const scaleMarginRecalcer = new ScaleAxisRecalcer(() => ScaleModel.getScaleLinear(options, data, canvasModel));
+        const dataModelRep = modelInstance.dataModel.repository;
+        const scaleModel = new ScaleModel();
+        const scaleMarginRecalcer = new ScaleAxisRecalcer(() => scaleModel.getScaleLinear(options, dataModelRep.getScopedRows(), canvasModel));
         scaleMarginRecalcer.recalculateMargin(canvasModel, options.orientation, options.axis.key);
         const scaleValueInfo = scaleMarginRecalcer.getScaleValue();
         return {
@@ -15,11 +17,11 @@ export class TwoDimensionalModel {
             selectable: !!options.selectable,
             orient: options.orientation,
             scale: {
-                key: ScaleModel.getScaleKey(modelInstance.dataModel.getAllowableKeys(), options.orientation, canvasModel, options.charts, this.getChartsByType(options.charts, 'bar')),
+                key: scaleModel.getScaleKey(modelInstance.dataModel.getAllowableKeys(), options.orientation, canvasModel, options.charts, this.getChartsByType(options.charts, 'bar')),
                 value: scaleValueInfo.scale
             },
             axis: {
-                key: AxisModel.getKeyAxis(options, data, designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip, () => scaleValueInfo.scaleFn(0)),
+                key: AxisModel.getKeyAxis(options, dataModelRep.getScopedFullSource(), designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip, () => scaleValueInfo.scaleFn(0)),
                 value: AxisModel.getValueAxis(options.orientation, options.axis.value, designerConfig.canvas.axisLabel, canvasModel)
             },
             type: options.type,

package/lib/style/charts-main.css

@@ -109,14 +109,14 @@
 
 
 /*========================================================================= Tooltip */
-.tooltip-block {
+.mdt-charts-tooltip-block {
     pointer-events: none;
     z-index: 100;
     filter: drop-shadow(0px 4px 10px rgba(0, 0, 0, 0.1));
     width: max-content;
     max-width: 500px;
 }
-.tooltip-content {
+.mdt-charts-tooltip-content {
     position: relative;
     pointer-events: none;
     font-family: "Roboto", sans-serif;
@@ -128,7 +128,7 @@
     background: rgba(0, 0, 0, 0.82);
     font-size: 11px;
 }
-.tooltip-arrow {
+.mdt-charts-tooltip-arrow {
     width: 0;
     height: 0;
     border-style: solid;
@@ -159,26 +159,26 @@
     font-weight: 400;
 }
 
-.tooltip-line {
+.mdt-charts-tooltip-line {
     stroke: #AAA;
     stroke-width: 1px;
     stroke-linecap: round;
 }
-.tooltip-content .tooltip-head {
+.mdt-charts-tooltip-content .tooltip-head {
     font-size: 12px;
     margin-bottom: 10px;
 }
-.tooltip-content .tooltip-texts {
+.mdt-charts-tooltip-content .tooltip-texts {
     width: 100%;
 }
 
-.tooltip-content .tooltip-text-item > span {
+.mdt-charts-tooltip-content .tooltip-text-item > span {
     display: block;
 }
-.tooltip-content .tooltip-text-item > span:first-of-type {
+.mdt-charts-tooltip-content .tooltip-text-item > span:first-of-type {
     flex: 1;
 }
-.tooltip-content .tooltip-text-item > span:last-of-type {
+.mdt-charts-tooltip-content .tooltip-text-item > span:last-of-type {
     flex: 0;
 }
 .tooltip-field-value {

package/lib/style/charts-main.less

@@ -109,14 +109,14 @@
 
 
 /*========================================================================= Tooltip */
-.tooltip-block {
+.mdt-charts-tooltip-block {
     pointer-events: none;
     z-index: 100;
     filter: drop-shadow(0px 4px 10px rgba(0, 0, 0, 0.1));
     width: max-content;
     max-width: 500px;
 }
-.tooltip-content {
+.mdt-charts-tooltip-content {
     position: relative;
     pointer-events: none;
     font-family: "Roboto", sans-serif;
@@ -128,7 +128,7 @@
     background: rgba(0, 0, 0, 0.82);
     font-size: 11px;
 }
-.tooltip-arrow {
+.mdt-charts-tooltip-arrow {
     width: 0;
     height: 0;
     border-style: solid;
@@ -159,26 +159,26 @@
     font-weight: 400;
 }
 
-.tooltip-line {
+.mdt-charts-tooltip-line {
     stroke: #AAA;
     stroke-width: 1px;
     stroke-linecap: round;
 }
-.tooltip-content .tooltip-head {
+.mdt-charts-tooltip-content .tooltip-head {
     font-size: 12px;
     margin-bottom: 10px;
 }
-.tooltip-content .tooltip-texts {
+.mdt-charts-tooltip-content .tooltip-texts {
     width: 100%;
 }
 
-.tooltip-content .tooltip-text-item > span {
+.mdt-charts-tooltip-content .tooltip-text-item > span {
     display: block;
 }
-.tooltip-content .tooltip-text-item > span:first-of-type {
+.mdt-charts-tooltip-content .tooltip-text-item > span:first-of-type {
     flex: 1;
 }
-.tooltip-content .tooltip-text-item > span:last-of-type {
+.mdt-charts-tooltip-content .tooltip-text-item > span:last-of-type {
     flex: 0;
 }
 .tooltip-field-value {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdt-charts",
-  "version": "1.12.11",
+  "version": "1.12.15",
   "description": "",
   "main": "lib/main.js",
   "scripts": {

package/tsconfig.production.json

@@ -18,6 +18,7 @@
         "node_modules",
         "**/__tests__/*",
         "src/playground/*",
-        "**/*Example.ts"
+        "**/*Example.ts",
+        "**/*.test.ts"
     ]
 }