mdt-charts 1.12.11 → 1.12.12

package/lib/engine/features/axis/axis.js

@@ -1,11 +1,11 @@
 import { Scale } from "../scale/scale";
-import { AXIS_VERTICAL_LABEL_PADDING } from "../../../model/marginModel";
 import { NamesHelper } from '../../helpers/namesHelper';
 import { AxisHelper } from './axisHelper';
 import { AxisLabelHelper } from './axisLabelDomHelper';
 import { AxisDomHelper } from './axisDomHelper';
 import { select } from 'd3-selection';
 import { AxisLabelsEventManager } from './axisLabelsEventManager';
+import { AXIS_VERTICAL_LABEL_PADDING } from '../../../model/margin/twoDim/twoDimMarginModel';
 const MINIMAL_STEP_SIZE_FOR_WRAPPING = 38;
 export class Axis {
     static render(block, scales, scaleModel, axisModel, blockSize) {

package/lib/engine/features/axis/axisLabelDomHelper.js

@@ -1,7 +1,7 @@
 import { select } from 'd3-selection';
-import { AXIS_HORIZONTAL_LABEL_PADDING, AXIS_VERTICAL_LABEL_PADDING } from "../../../model/marginModel";
 import { DomHelper } from '../../helpers/domHelper';
 import { Helper } from '../../helpers/helper';
+import { AXIS_HORIZONTAL_LABEL_PADDING, AXIS_VERTICAL_LABEL_PADDING } from '../../../model/margin/twoDim/twoDimMarginModel';
 export class AxisLabelHelper {
     static setTitles(axisElement) {
         axisElement.selectAll('.tick text')

package/lib/model/dataManagerModel/dataManagerModel.d.ts

@@ -14,6 +14,7 @@ export declare class DataManagerModel {
     private static polarMarginCalculator;
     static getPreparedData(data: MdtChartsDataSource, allowableKeys: string[], config: MdtChartsConfig): MdtChartsDataSource;
     static initDataScope(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig, legendBlock: LegendBlockModel, modelInstance: ModelInstance): void;
+    private static initScopedData;
     static getDataValuesByKeyField(data: MdtChartsDataSource, dataSourceName: string, keyFieldName: string): string[];
     private static initDataScopeFor2D;
     private static initDataScopeForPolar;

package/lib/model/dataManagerModel/dataManagerModel.js

@@ -17,6 +17,11 @@ export class DataManagerModel {
         else if (config.options.type === 'polar') {
             this.initDataScopeForPolar(config.options, modelInstance, data, legendBlock, designerConfig.canvas.legendBlock);
         }
+        this.initScopedData(data, modelInstance, config);
+    }
+    static initScopedData(data, modelInstance, config) {
+        const preparedData = DataManagerModel.getPreparedData(data, modelInstance.dataModel.getAllowableKeys(), config);
+        modelInstance.dataModel.repository.initScopedFullSource(preparedData);
     }
     static getDataValuesByKeyField(data, dataSourceName, keyFieldName) {
         return data[dataSourceName].map(dataRow => dataRow[keyFieldName]);

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

@@ -10,12 +10,12 @@ export class LegendModel {
                 },
                 bottom: {
                     size: 0,
-                    margin: { top: 0, bottom: 20, left: 0, right: 0 },
+                    margin: { top: 5, bottom: 20, left: 0, right: 0 },
                     pad: 0
                 },
                 right: {
                     size: 0,
-                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 5, right: 0 },
+                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 10, right: 0 },
                     pad: 0
                 },
                 top: {

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

@@ -1,5 +1,5 @@
 import { getPxPercentUnitByValue } from "../../helpers/unitsFromConfigReader";
-import { MarginModel } from "../../marginModel";
+import { MarginModel } from "../../margin/marginModel";
 export class LegendPolarMarginCalculator {
     updateMargin(legendPosition, canvasModel, legendBlockModel, size) {
         canvasModel.legendCanvas.setPosition(legendPosition);

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

@@ -1,4 +1,4 @@
-import { MarginModel } from "../../marginModel";
+import { MarginModel } from "../../margin/marginModel";
 export class TwoDimLegendModel {
     recalcMarginWith2DLegend(modelInstance, legendBlockModel) {
         const canvasModel = modelInstance.canvasModel;

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

@@ -7,10 +7,10 @@ export declare enum ScaleType {
 }
 export declare class ScaleModel {
     static getScaleKey(allowableKeys: string[], orient: ChartOrientation, canvasModel: CanvasModel, charts: MdtChartsTwoDimensionalChart[], barCharts: MdtChartsTwoDimensionalChart[]): ScaleKeyModel;
-    static getScaleLinear(options: MdtChartsTwoDimensionalOptions, data: MdtChartsDataSource, canvasModel: CanvasModel): ScaleValueModel;
+    static getScaleLinear(options: MdtChartsTwoDimensionalOptions, dataRows: MdtChartsDataRow[], canvasModel: CanvasModel): ScaleValueModel;
     static getRangePeek(scaleType: ScaleType, chartOrientation: string, canvasModel: CanvasModel): number;
     static getDateValueDomain(data: MdtChartsDataSource, chart: IntervalChart, keyAxisPosition: AxisPosition, dataSource: string): [Date, Date];
-    static getLinearDomain(configDomain: NumberDomain, data: MdtChartsDataSource, configOptions: MdtChartsTwoDimensionalOptions): [number, number];
+    static getLinearDomain(configDomain: NumberDomain, dataRows: MdtChartsDataRow[], configOptions: MdtChartsTwoDimensionalOptions): [number, number];
     static getScaleKeyType(charts: MdtChartsTwoDimensionalChart[]): ScaleKeyType;
     static getScaleValueType(charts: MdtChartsTwoDimensionalChart[] | IntervalChart[]): ScaleValueType;
     static getElementsAmount(barCharts: MdtChartsTwoDimensionalChart[]): number;

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

@@ -16,9 +16,9 @@ export class ScaleModel {
             elementsAmount: this.getElementsAmount(barCharts)
         };
     }
-    static getScaleLinear(options, data, canvasModel) {
+    static getScaleLinear(options, dataRows, canvasModel) {
         return {
-            domain: ScaleModel.getLinearDomain(options.axis.value.domain, data, options),
+            domain: ScaleModel.getLinearDomain(options.axis.value.domain, dataRows, options),
             range: {
                 start: 0,
                 end: ScaleModel.getRangePeek(ScaleType.Value, options.orientation, canvasModel)
@@ -43,15 +43,15 @@ export class ScaleModel {
             return [domainPeekMin, domainPeekMax];
         return [domainPeekMax, domainPeekMin];
     }
-    static getLinearDomain(configDomain, data, configOptions) {
+    static getLinearDomain(configDomain, dataRows, configOptions) {
         let domainPeekMin;
         let domainPeekMax;
         if (configDomain.start === -1)
-            domainPeekMin = this.getScaleMinValue(configOptions.charts, data[configOptions.data.dataSource]);
+            domainPeekMin = this.getScaleMinValue(configOptions.charts, dataRows);
         else
             domainPeekMin = configDomain.start;
         if (configDomain.end === -1)
-            domainPeekMax = this.getScaleMaxValue(configOptions.charts, data[configOptions.data.dataSource]);
+            domainPeekMax = this.getScaleMaxValue(configOptions.charts, dataRows);
         else
             domainPeekMax = configDomain.end;
         if (configOptions.axis.key.position === 'start')

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

@@ -0,0 +1,11 @@
+import { MdtChartsConfig, MdtChartsDataSource, MdtChartsTwoDimensionalOptions } from "../../config/config";
+import { DesignerConfig } from "../../designer/designerConfig";
+import { LegendBlockModel, Orient, OtherCommonComponents } from "../model";
+import { ModelInstance } from "../modelInstance/modelInstance";
+import { CanvasModel } from "../modelInstance/canvasModel/canvasModel";
+export declare class MarginModel {
+    static initMargin(designerConfig: DesignerConfig, config: MdtChartsConfig, otherComponents: OtherCommonComponents, data: MdtChartsDataSource, modelInstance: ModelInstance): void;
+    static recalcMarginByVerticalAxisLabel(modelInstance: ModelInstance, options: MdtChartsTwoDimensionalOptions, designerConfig: DesignerConfig): void;
+    static appendToGlobalMarginValuesLegendMargin(canvasModel: CanvasModel, position: Orient, legendBlockModel: LegendBlockModel): void;
+    private static recalcMarginByTitle;
+}

package/lib/model/margin/marginModel.js

@@ -0,0 +1,26 @@
+import { TwoDimMarginModel } from "./twoDim/twoDimMarginModel";
+export class MarginModel {
+    static initMargin(designerConfig, config, otherComponents, data, modelInstance) {
+        const canvasModel = modelInstance.canvasModel;
+        canvasModel.initMargin(Object.assign({}, designerConfig.canvas.chartBlockMargin));
+        this.recalcMarginByTitle(canvasModel, otherComponents.titleBlock);
+        if (config.options.type === '2d') {
+            const twoDimModel = new TwoDimMarginModel();
+            twoDimModel.recalcMargin(designerConfig, config.options, otherComponents, data, modelInstance);
+        }
+    }
+    static recalcMarginByVerticalAxisLabel(modelInstance, options, designerConfig) {
+        const twoDimModel = new TwoDimMarginModel();
+        twoDimModel.recalcMarginByVerticalAxisLabel(modelInstance, options, designerConfig);
+    }
+    static appendToGlobalMarginValuesLegendMargin(canvasModel, position, legendBlockModel) {
+        const legendCoordinate = legendBlockModel.coordinate;
+        if (position === 'left' || position === 'right')
+            canvasModel.increaseMarginSide(position, legendCoordinate[position].margin.left + legendCoordinate[position].margin.right);
+        else
+            canvasModel.increaseMarginSide(position, legendCoordinate[position].margin.top + legendCoordinate[position].margin.bottom);
+    }
+    static recalcMarginByTitle(canvasModel, titleBlockModel) {
+        canvasModel.increaseMarginSide("top", titleBlockModel.margin.top + titleBlockModel.size + titleBlockModel.margin.bottom);
+    }
+}

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) {
@@ -70,13 +70,11 @@ export function assembleModel(config, data, designerConfig) {
     const otherComponents = OtherComponentsModel.getOtherComponentsModel({ elementsOptions: designerConfig.elementsOptions, 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);
-    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 +109,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/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

@@ -5,9 +5,9 @@ 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,7 +15,7 @@ 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)
@@ -24,7 +24,7 @@ export class IntervalModel {
                     elementsAmount: 1
                 },
                 value: {
-                    domain: ScaleModel.getDateValueDomain(data, options.chart, options.axis.key.position, options.data.dataSource),
+                    domain: ScaleModel.getDateValueDomain(dataModelRep.getScopedFullSource(), options.chart, options.axis.key.position, options.data.dataSource),
                     range: {
                         start: 0,
                         end: ScaleModel.getRangePeek(ScaleType.Value, options.orientation, canvasModel)
@@ -43,8 +43,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/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,10 @@ 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 scaleMarginRecalcer = new ScaleAxisRecalcer(() => ScaleModel.getScaleLinear(options, dataModelRep.getScopedRows(), canvasModel));
         scaleMarginRecalcer.recalculateMargin(canvasModel, options.orientation, options.axis.key);
         const scaleValueInfo = scaleMarginRecalcer.getScaleValue();
         return {
@@ -19,7 +20,7 @@ export class TwoDimensionalModel {
                 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/package.json

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