mdt-charts 1.12.14 → 1.12.17

package/lib/engine/twoDimensionalNotation/line/line.d.ts

@@ -10,7 +10,7 @@ export declare class Line {
     private static renderGrouped;
     private static renderSegmented;
     private static updateGrouped;
-    private static updateSegmeneted;
+    private static updateSegmented;
     private static updateGroupedPath;
     private static updateSegmentedPath;
     private static setSegmentColor;

package/lib/engine/twoDimensionalNotation/line/line.js

@@ -14,7 +14,7 @@ export class Line {
     static update(block, scales, newData, keyField, margin, keyAxisOrient, chart) {
         let promises;
         if (chart.isSegmented) {
-            promises = this.updateSegmeneted(block, scales, newData, keyField, margin, keyAxisOrient, chart);
+            promises = this.updateSegmented(block, scales, newData, keyField, margin, keyAxisOrient, chart);
         }
         else {
             promises = this.updateGrouped(block, scales, newData, keyField, margin, keyAxisOrient, chart);
@@ -23,7 +23,7 @@ export class Line {
     }
     static updateColors(block, chart) {
         chart.data.valueFields.forEach((_vf, valueIndex) => {
-            const path = block.getChartGroup(chart.index)
+            const path = block.svg.getChartGroup(chart.index)
                 .select(`.${this.lineChartClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${valueIndex}`);
             DomHelper.setChartStyle(path, chart.style, valueIndex, 'stroke');
             MarkDot.updateColors(block, chart, valueIndex);
@@ -32,12 +32,12 @@ export class Line {
     static renderGrouped(block, scales, data, keyField, margin, keyAxisOrient, chart) {
         chart.data.valueFields.forEach((valueField, valueIndex) => {
             const lineGenerator = LineHelper.getLineGenerator(keyAxisOrient, scales, keyField.name, valueField.name, margin);
-            const path = block.getChartGroup(chart.index)
+            const path = block.svg.getChartGroup(chart.index)
                 .append('path')
                 .attr('d', lineGenerator(data))
                 .attr('class', this.lineChartClass)
                 .style('fill', 'none')
-                .style('clip-path', `url(#${block.getClipPathId()})`)
+                .style('clip-path', `url(#${block.svg.getClipPathId()})`)
                 .style('pointer-events', 'none');
             DomHelper.setCssClasses(path, Helper.getCssClassesWithElementIndex(chart.cssClasses, valueIndex));
             DomHelper.setChartStyle(path, chart.style, valueIndex, 'stroke');
@@ -47,7 +47,7 @@ export class Line {
     static renderSegmented(block, scales, data, keyField, margin, keyAxisOrient, chart) {
         const stackedData = stack().keys(chart.data.valueFields.map(field => field.name))(data);
         const lineGenerator = LineHelper.getSegmentedLineGenerator(keyAxisOrient, scales, keyField.name, margin);
-        const lines = block.getChartGroup(chart.index)
+        const lines = block.svg.getChartGroup(chart.index)
             .selectAll(`.${this.lineChartClass}${Helper.getCssClassesLine(chart.cssClasses)}`)
             .data(stackedData)
             .enter()
@@ -55,7 +55,7 @@ export class Line {
             .attr('d', d => lineGenerator(d))
             .attr('class', this.lineChartClass)
             .style('fill', 'none')
-            .style('clip-path', `url(#${block.getClipPathId()})`)
+            .style('clip-path', `url(#${block.svg.getClipPathId()})`)
             .style('pointer-events', 'none');
         lines.each(function (d, i) {
             DomHelper.setCssClasses(select(this), Helper.getCssClassesWithElementIndex(chart.cssClasses, i));
@@ -69,7 +69,7 @@ export class Line {
         const promises = [];
         chart.data.valueFields.forEach((valueField, valueFieldIndex) => {
             const lineGenerator = LineHelper.getLineGenerator(keyAxisOrient, scales, keyField.name, valueField.name, margin);
-            const lineObject = block.getChartGroup(chart.index)
+            const lineObject = block.svg.getChartGroup(chart.index)
                 .select(`.${this.lineChartClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${valueFieldIndex}`);
             const prom = this.updateGroupedPath(block, lineObject, lineGenerator, newData);
             promises.push(prom);
@@ -77,10 +77,10 @@ export class Line {
         });
         return promises;
     }
-    static updateSegmeneted(block, scales, newData, keyField, margin, keyAxisOrient, chart) {
+    static updateSegmented(block, scales, newData, keyField, margin, keyAxisOrient, chart) {
         const stackedData = stack().keys(chart.data.valueFields.map(field => field.name))(newData);
         const lineGenerator = LineHelper.getSegmentedLineGenerator(keyAxisOrient, scales, keyField.name, margin);
-        const lines = block.getChartGroup(chart.index)
+        const lines = block.svg.getChartGroup(chart.index)
             .selectAll(`path.${this.lineChartClass}${Helper.getCssClassesLine(chart.cssClasses)}`)
             .data(stackedData);
         const prom = this.updateSegmentedPath(block, lines, lineGenerator);

package/lib/engine/twoDimensionalNotation/twoDimensionalManager.d.ts

@@ -1,11 +1,12 @@
 import { MdtChartsDataSource } from "../../config/config";
-import { Model } from "../../model/model";
+import { Model, TwoDimensionalOptionsModel } from "../../model/model";
 import { Block } from "../block/block";
-import Engine from "../engine";
-export declare class TwoDimensionalManager {
-    static render(engine: Engine, model: Model): void;
-    static updateData(block: Block, model: Model, data: MdtChartsDataSource): void;
-    static updateColors(block: Block, model: Model): void;
-    private static renderCharts;
-    private static updateCharts;
+import { ChartContentManager } from "../contentManager/contentManagerFactory";
+import { Engine } from "../engine";
+export declare class TwoDimensionalManager implements ChartContentManager {
+    render(engine: Engine, model: Model<TwoDimensionalOptionsModel>): void;
+    updateData(block: Block, model: Model<TwoDimensionalOptionsModel>, data: MdtChartsDataSource): void;
+    updateColors(block: Block, model: Model<TwoDimensionalOptionsModel>): void;
+    private renderCharts;
+    private updateCharts;
 }

package/lib/engine/twoDimensionalNotation/twoDimensionalManager.js

@@ -14,11 +14,11 @@ import { BarHelper } from "./bar/barHelper";
 import { TwoDimRecordOverflowAlert } from "./extenders/twoDimRecordOverflowAlert";
 import { Line } from "./line/line";
 export class TwoDimensionalManager {
-    static render(engine, model) {
+    render(engine, model) {
         const options = model.options;
         const scales = Scale.getScales(options.scale.key, options.scale.value, options.chartSettings.bar);
         engine.block.scales = scales;
-        engine.block.renderSvg(model.blockCanvas.size);
+        engine.block.svg.render(model.blockCanvas.size);
         Axis.render(engine.block, scales, options.scale, options.axis, model.blockCanvas.size);
         GridLine.render(engine.block, options.additionalElements.gridLine.flag, options.axis, model.blockCanvas.size, model.chartBlock.margin, scales);
         this.renderCharts(engine.block, options.charts, scales, engine.data, options.data, model.chartBlock.margin, options.axis.key.orient, options.chartSettings.bar, model.blockCanvas.size);
@@ -39,7 +39,7 @@ export class TwoDimensionalManager {
                 engine.block.filterEventManager.clearKeysFor2D(options);
         });
     }
-    static updateData(block, model, data) {
+    updateData(block, model, data) {
         block.transitionManager.interruptTransitions();
         block.filterEventManager.updateData(data[model.options.data.dataSource]);
         TipBox.clearEvents(block);
@@ -63,7 +63,7 @@ export class TwoDimensionalManager {
             chartOrientation: options.orient
         });
     }
-    static updateColors(block, model) {
+    updateColors(block, model) {
         Legend.updateColors(block, model.options);
         model.options.charts.forEach(chart => {
             if (chart.type === 'bar')
@@ -74,9 +74,9 @@ export class TwoDimensionalManager {
                 Area.updateColors(block, chart);
         });
     }
-    static renderCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, barSettings, blockSize) {
-        block.renderChartClipPath(margin, blockSize);
-        block.renderChartsBlock();
+    renderCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, barSettings, blockSize) {
+        block.svg.renderChartClipPath(margin, blockSize);
+        block.svg.renderChartsBlock();
         charts.forEach((chart) => {
             if (chart.type === 'bar')
                 Bar.render(block, scales, data[dataOptions.dataSource], dataOptions.keyField, margin, keyAxisOrient, chart, blockSize, barSettings, BarHelper.getBarsInGroupAmount(charts), chart.isSegmented, charts.findIndex(ch => ch.type === 'bar'));
@@ -87,8 +87,8 @@ export class TwoDimensionalManager {
         });
         EmbeddedLabels.raiseGroups(block);
     }
-    static updateCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, blockSize, barSettings) {
-        block.updateChartClipPath(margin, blockSize);
+    updateCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, blockSize, barSettings) {
+        block.svg.updateChartClipPath(margin, blockSize);
         let promises = [];
         charts.forEach((chart) => {
             let proms;

package/lib/main.js

@@ -1,4 +1,4 @@
-import Engine from "./engine/engine";
+import { Engine } from "./engine/engine";
 import { assembleModel, getPreparedData } from "./model/modelBuilder";
 import { PublicOptionsService } from "./optionsServices/publicOptionsService";
 export class Chart {

package/lib/model/chartStyleModel/chartStyleModel.d.ts

@@ -1,7 +1,7 @@
 import { ChartStyleConfig } from "../../designer/designerConfig";
 import { ChartStyle } from "../model";
 export declare class ChartStyleModelService {
-    private static standartColors;
+    private static standardColors;
     static getCssClasses(chartIndex: number): string[];
     static getChartStyle(elementsAmount: number, styleConfig: ChartStyleConfig): ChartStyle;
     static getColorSet(baseColors: string[], elementsAmount: number): string[];

package/lib/model/chartStyleModel/chartStyleModel.js

@@ -19,9 +19,9 @@ export class ChartStyleModelService {
     }
     static checkAndGet(baseColors) {
         if (baseColors.length === 0 || baseColors.filter(color => color === 'rgba(0, 0, 0, 0)' || !color).length > 0) {
-            return this.standartColors;
+            return this.standardColors;
         }
         return baseColors;
     }
 }
-ChartStyleModelService.standartColors = ["#209DE3", "#FF3131", "#FFBA00", "#20B078"];
+ChartStyleModelService.standardColors = ["#209DE3", "#FF3131", "#FFBA00", "#20B078"];

package/lib/model/chartStyleModel/colorRange.d.ts

@@ -0,0 +1,7 @@
+import { MdtChartsColorRangeItem } from "../../config/config";
+export declare class ColorRangeManager {
+    private sortedRange;
+    constructor(range: MdtChartsColorRangeItem[]);
+    getColorByValue(value: number): string;
+}
+export declare function sortColorRange(colorRange: MdtChartsColorRangeItem[]): MdtChartsColorRangeItem[];

package/lib/model/chartStyleModel/colorRange.js

@@ -0,0 +1,30 @@
+export class ColorRangeManager {
+    constructor(range) {
+        this.sortedRange = sortColorRange(range);
+    }
+    getColorByValue(value) {
+        for (let i = 0; i < this.sortedRange.length; i++) {
+            const currentItem = this.sortedRange[i];
+            const nextItem = this.sortedRange[i + 1];
+            if (!nextItem)
+                return currentItem.color;
+            if (currentItem.value == null && value < nextItem.value)
+                return currentItem.color;
+            if (currentItem.value === value)
+                return currentItem.color;
+            if (value >= currentItem.value && value < nextItem.value)
+                return currentItem.color;
+        }
+    }
+}
+export function sortColorRange(colorRange) {
+    const range = [...colorRange];
+    range.sort((a, b) => {
+        if (a.value == null)
+            return -1;
+        return a.value < b.value
+            ? -1
+            : (a.value == b.value ? 0 : 1);
+    });
+    return range;
+}

package/lib/model/dataManagerModel/dataManagerModel.js

@@ -4,6 +4,7 @@ import { ModelHelper } from "../helpers/modelHelper";
 import { MIN_DONUT_BLOCK_SIZE, PolarModel } from "../notations/polar/polarModel";
 import { DataManagerModelService } from "./dataManagerModelService";
 import { LegendPolarMarginCalculator } from "../featuresModel/legendModel/polarMarginCalculator";
+import { CardsDataManagerModel } from "./notations/cardsDataManagerModel";
 export class DataManagerModel {
     static getPreparedData(data, allowableKeys, config) {
         const scopedData = this.getScopedData(data, allowableKeys, config);
@@ -17,6 +18,10 @@ export class DataManagerModel {
         else if (config.options.type === 'polar') {
             this.initDataScopeForPolar(config.options, modelInstance, data, legendBlock, designerConfig.canvas.legendBlock);
         }
+        else if (config.options.type === "card") {
+            const manager = new CardsDataManagerModel();
+            manager.initDataScope(modelInstance, data, config.options);
+        }
         this.initScopedData(data, modelInstance, config);
     }
     static initScopedData(data, modelInstance, config) {
@@ -54,6 +59,7 @@ export class DataManagerModel {
         const keyFieldName = configOptions.data.keyField.name;
         const keys = data[configOptions.data.dataSource].map(dataRow => dataRow[keyFieldName]);
         if (!configOptions.legend.show) {
+            canvasModel.legendCanvas.setPosition("off");
             modelInstance.dataModel.initScope(this.getMaximumPossibleScope(keys, modelInstance.dataModel));
             return;
         }
@@ -71,6 +77,7 @@ export class DataManagerModel {
         //TODO: global refactor of method
         const allowableKeys = keys.slice(0, maxItemsNumber);
         const hidedRecordsAmount = keys.length - maxItemsNumber;
+        canvasModel.legendCanvas.setPosition(position);
         this.polarMarginCalculator.updateMargin(position, canvasModel, legendBlock, position === "bottom" ? size.height : size.width);
         modelInstance.dataModel.initScope(this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel));
     }

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

@@ -0,0 +1,5 @@
+import { MdtChartsCardsOptions, MdtChartsDataSource } from "../../../config/config";
+import { ModelInstance } from "../../modelInstance/modelInstance";
+export declare class CardsDataManagerModel {
+    initDataScope(modelInstance: ModelInstance, data: MdtChartsDataSource, configOptions: MdtChartsCardsOptions): void;
+}

package/lib/model/dataManagerModel/notations/cardsDataManagerModel.js

@@ -0,0 +1,10 @@
+import { DataManagerModel } from "../dataManagerModel";
+export class CardsDataManagerModel {
+    initDataScope(modelInstance, data, configOptions) {
+        const firstKey = DataManagerModel.getDataValuesByKeyField(data, configOptions.data.dataSource, configOptions.data.keyField.name)[0];
+        modelInstance.dataModel.initScope({
+            allowableKeys: [firstKey],
+            hidedRecordsAmount: 0
+        });
+    }
+}

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

@@ -1,7 +1,8 @@
-import { LegendBlockModel } from "../../model";
+import { LegendBlockModel, Orient } from "../../model";
 import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
 import { LegendItemsDirection } from "./legendCanvasModel";
 export declare class LegendModel {
     static getBaseLegendBlockModel(canvasModel: CanvasModel): LegendBlockModel;
     static getLegendItemClass(itemsPosition: LegendItemsDirection): string;
+    static appendToGlobalMarginValuesLegendMargin(canvasModel: CanvasModel, position: Orient, legendBlockModel: LegendBlockModel): void;
 }

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

@@ -29,4 +29,11 @@ export class LegendModel {
     static getLegendItemClass(itemsPosition) {
         return itemsPosition === 'column' ? 'legend-item-row' : 'legend-item-inline';
     }
+    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);
+    }
 }

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

@@ -1,8 +1,7 @@
 import { getPxPercentUnitByValue } from "../../helpers/unitsFromConfigReader";
-import { MarginModel } from "../../margin/marginModel";
+import { LegendModel } from "./legendModel";
 export class LegendPolarMarginCalculator {
     updateMargin(legendPosition, canvasModel, legendBlockModel, size) {
-        canvasModel.legendCanvas.setPosition(legendPosition);
         this.updateMarginObj(legendBlockModel, legendPosition, size, canvasModel);
     }
     getMaxLegendWidth(legendCanvas, blockWidth) {
@@ -18,7 +17,7 @@ export class LegendPolarMarginCalculator {
     updateMarginObj(legendBlockModel, legendPosition, legendSize, canvasModel) {
         if (legendSize !== 0) {
             canvasModel.increaseMarginSide(legendPosition, legendSize);
-            MarginModel.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
+            LegendModel.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
         }
         legendBlockModel.coordinate[legendPosition].size = legendSize;
     }

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

@@ -1,7 +1,8 @@
+import { Legend } from "../../../config/config";
 import { LegendBlockModel } from "../../model";
 import { ModelInstance } from "../../modelInstance/modelInstance";
 export declare class TwoDimLegendModel {
-    recalcMarginWith2DLegend(modelInstance: ModelInstance, legendBlockModel: LegendBlockModel): void;
+    recalcMarginWith2DLegend(modelInstance: ModelInstance, legendBlockModel: LegendBlockModel, legendOptions: Legend): void;
     private getLegendSize;
     private getLegendModel;
 }

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

@@ -1,14 +1,14 @@
-import { MarginModel } from "../../margin/marginModel";
+import { LegendModel } from "./legendModel";
 export class TwoDimLegendModel {
-    recalcMarginWith2DLegend(modelInstance, legendBlockModel) {
+    recalcMarginWith2DLegend(modelInstance, legendBlockModel, legendOptions) {
         const canvasModel = modelInstance.canvasModel;
-        const legendPosition = this.getLegendModel().position;
+        const legendPosition = this.getLegendModel(legendOptions).position;
         modelInstance.canvasModel.legendCanvas.setPosition(legendPosition);
         if (legendPosition !== 'off') {
             const legendSize = this.getLegendSize();
             canvasModel.increaseMarginSide(legendPosition, legendSize);
             if (legendSize !== 0)
-                MarginModel.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
+                LegendModel.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
             legendBlockModel.coordinate[legendPosition].size = legendSize;
         }
     }
@@ -16,9 +16,10 @@ export class TwoDimLegendModel {
         const heightOfLegendItemWithoutWordWrapping = 20;
         return heightOfLegendItemWithoutWordWrapping;
     }
-    getLegendModel() {
+    getLegendModel(legendOptions) {
+        const position = legendOptions.show ? "top" : "off";
         return {
-            position: "top"
+            position
         };
     }
 }

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

@@ -0,0 +1,6 @@
+import { MdtChartsDataRow, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions, NumberDomain } from "../../../config/config";
+export declare function getScaleLinearDomain(configDomain: NumberDomain, dataRows: MdtChartsDataRow[], configOptions: MdtChartsTwoDimensionalOptions): number[];
+export declare class ScaleDomainCalculator {
+    getScaleMinValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;
+    getScaleMaxValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;
+}

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

@@ -0,0 +1,53 @@
+export function getScaleLinearDomain(configDomain, dataRows, configOptions) {
+    const calculator = new ScaleDomainCalculator();
+    let domainPeekMin;
+    let domainPeekMax;
+    if (configDomain.start === -1)
+        domainPeekMin = calculator.getScaleMinValue(configOptions.charts, dataRows);
+    else
+        domainPeekMin = configDomain.start;
+    if (configDomain.end === -1)
+        domainPeekMax = calculator.getScaleMaxValue(configOptions.charts, dataRows);
+    else
+        domainPeekMax = configDomain.end;
+    if (configOptions.axis.key.position === 'start')
+        return [domainPeekMin, domainPeekMax];
+    return [domainPeekMax, domainPeekMin];
+}
+export class ScaleDomainCalculator {
+    getScaleMinValue(charts, dataRows) {
+        let min = 0;
+        charts.forEach(chart => {
+            dataRows.forEach(dataRow => {
+                let sumInRow = 0;
+                chart.data.valueFields.forEach(field => {
+                    if (chart.isSegmented && dataRow[field.name] < 0) {
+                        sumInRow += dataRow[field.name];
+                    }
+                    else if (dataRow[field.name] < sumInRow)
+                        sumInRow = dataRow[field.name];
+                });
+                if (min > sumInRow)
+                    min = sumInRow;
+            });
+        });
+        return min;
+    }
+    getScaleMaxValue(charts, dataRows) {
+        let max = 0;
+        charts.forEach(chart => {
+            dataRows.forEach(dataRow => {
+                let sumInRow = 0;
+                chart.data.valueFields.forEach(field => {
+                    if (chart.isSegmented && dataRow[field.name] > 0)
+                        sumInRow += dataRow[field.name];
+                    else if (dataRow[field.name] > sumInRow)
+                        sumInRow = dataRow[field.name];
+                });
+                if (max < sumInRow)
+                    max = sumInRow;
+            });
+        });
+        return max;
+    }
+}

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

@@ -1,19 +1,12 @@
-import { ScaleKeyModel, ScaleKeyType, ScaleValueModel, ScaleValueType } from "../../model";
-import { AxisPosition, NumberDomain, IntervalChart, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions, ChartOrientation, MdtChartsDataSource, MdtChartsDataRow } from "../../../config/config";
+import { ScaleKeyModel, ScaleValueModel } from "../../model";
+import { MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions, ChartOrientation, MdtChartsDataRow } 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, canvasModel: CanvasModel, charts: MdtChartsTwoDimensionalChart[], barCharts: MdtChartsTwoDimensionalChart[]): ScaleKeyModel;
-    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, dataRows: MdtChartsDataRow[], configOptions: MdtChartsTwoDimensionalOptions): [number, number];
-    static getScaleKeyType(charts: MdtChartsTwoDimensionalChart[]): ScaleKeyType;
-    static getScaleValueType(charts: MdtChartsTwoDimensionalChart[] | IntervalChart[]): ScaleValueType;
-    static getElementsAmount(barCharts: MdtChartsTwoDimensionalChart[]): number;
-    static getScaleMaxValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;
-    static getScaleMinValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;
+    getScaleKey(allowableKeys: string[], orient: ChartOrientation, canvasModel: CanvasModel, charts: MdtChartsTwoDimensionalChart[], barCharts: MdtChartsTwoDimensionalChart[]): ScaleKeyModel;
+    getScaleLinear(options: MdtChartsTwoDimensionalOptions, dataRows: MdtChartsDataRow[], canvasModel: CanvasModel): ScaleValueModel;
+    private getScaleKeyType;
 }

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

@@ -1,118 +1,35 @@
-import { ModelHelper } from "../../helpers/modelHelper";
+import { getElementsAmountForScale, getScaleKeyRangePeek, getScaleValueRangePeek } from "./scaleModelServices";
+import { getScaleLinearDomain } from "./scaleDomainService";
 export var ScaleType;
 (function (ScaleType) {
     ScaleType[ScaleType["Key"] = 0] = "Key";
     ScaleType[ScaleType["Value"] = 1] = "Value";
 })(ScaleType || (ScaleType = {}));
 export class ScaleModel {
-    static getScaleKey(allowableKeys, orient, canvasModel, charts, barCharts) {
+    getScaleKey(allowableKeys, orient, canvasModel, charts, barCharts) {
         return {
             domain: allowableKeys,
             range: {
                 start: 0,
-                end: ScaleModel.getRangePeek(ScaleType.Key, orient, canvasModel)
+                end: getScaleKeyRangePeek(orient, canvasModel)
             },
-            type: ScaleModel.getScaleKeyType(charts),
-            elementsAmount: this.getElementsAmount(barCharts)
+            type: this.getScaleKeyType(charts),
+            elementsAmount: getElementsAmountForScale(barCharts)
         };
     }
-    static getScaleLinear(options, dataRows, canvasModel) {
+    getScaleLinear(options, dataRows, canvasModel) {
         return {
-            domain: ScaleModel.getLinearDomain(options.axis.value.domain, dataRows, options),
+            domain: getScaleLinearDomain(options.axis.value.domain, dataRows, options),
             range: {
                 start: 0,
-                end: ScaleModel.getRangePeek(ScaleType.Value, options.orientation, canvasModel)
+                end: getScaleValueRangePeek(options.orientation, canvasModel)
             },
-            type: ScaleModel.getScaleValueType(options.charts)
+            type: "linear"
         };
     }
-    static getRangePeek(scaleType, chartOrientation, canvasModel) {
-        if (chartOrientation === 'vertical')
-            return scaleType === ScaleType.Key
-                ? canvasModel.getChartBlockWidth()
-                : canvasModel.getChartBlockHeight();
-        return scaleType === ScaleType.Key
-            ? canvasModel.getChartBlockHeight()
-            : canvasModel.getChartBlockWidth();
-    }
-    static getDateValueDomain(data, chart, keyAxisPosition, dataSource) {
-        const minMax = ModelHelper.getMinAndMaxOfIntervalData(data, dataSource, chart);
-        let domainPeekMin = minMax[0];
-        let domainPeekMax = minMax[1];
-        if (keyAxisPosition === 'start')
-            return [domainPeekMin, domainPeekMax];
-        return [domainPeekMax, domainPeekMin];
-    }
-    static getLinearDomain(configDomain, dataRows, configOptions) {
-        let domainPeekMin;
-        let domainPeekMax;
-        if (configDomain.start === -1)
-            domainPeekMin = this.getScaleMinValue(configOptions.charts, dataRows);
-        else
-            domainPeekMin = configDomain.start;
-        if (configDomain.end === -1)
-            domainPeekMax = this.getScaleMaxValue(configOptions.charts, dataRows);
-        else
-            domainPeekMax = configDomain.end;
-        if (configOptions.axis.key.position === 'start')
-            return [domainPeekMin, domainPeekMax];
-        return [domainPeekMax, domainPeekMin];
-    }
-    static getScaleKeyType(charts) {
+    getScaleKeyType(charts) {
         if (charts.findIndex((chart) => chart.type === 'bar') === -1)
             return 'point';
         return 'band';
     }
-    static getScaleValueType(charts) {
-        if (charts.findIndex((chart) => chart.type === 'gantt') !== -1)
-            return 'datetime';
-        return 'linear';
-    }
-    static getElementsAmount(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;
-    }
-    static getScaleMaxValue(charts, dataRows) {
-        let max = 0;
-        charts.forEach(chart => {
-            dataRows.forEach(dataRow => {
-                let sumInRow = 0;
-                chart.data.valueFields.forEach(field => {
-                    if (chart.isSegmented && dataRow[field.name] > 0)
-                        sumInRow += dataRow[field.name];
-                    else if (dataRow[field.name] > sumInRow)
-                        sumInRow = dataRow[field.name];
-                });
-                if (max < sumInRow)
-                    max = sumInRow;
-            });
-        });
-        return max;
-    }
-    static getScaleMinValue(charts, dataRows) {
-        let min = 0;
-        charts.forEach(chart => {
-            dataRows.forEach(dataRow => {
-                let sumInRow = 0;
-                chart.data.valueFields.forEach(field => {
-                    if (chart.isSegmented && dataRow[field.name] < 0) {
-                        sumInRow += dataRow[field.name];
-                    }
-                    else if (dataRow[field.name] < sumInRow)
-                        sumInRow = dataRow[field.name];
-                });
-                if (min > sumInRow)
-                    min = sumInRow;
-            });
-        });
-        return min;
-    }
 }

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

@@ -0,0 +1,5 @@
+import { ChartOrientation, MdtChartsTwoDimensionalChart } from "../../../config/config";
+import { CanvasSizesModel } from "../../modelInstance/canvasModel/canvasSizesModel/canvasSizeModel";
+export declare function getScaleKeyRangePeek(chartOrientation: ChartOrientation, canvasModel: CanvasSizesModel): number;
+export declare function getScaleValueRangePeek(chartOrientation: string, canvasModel: CanvasSizesModel): number;
+export declare function getElementsAmountForScale(barCharts: MdtChartsTwoDimensionalChart[]): number;

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

@@ -1,11 +1,10 @@
 import { MdtChartsConfig, MdtChartsDataSource, MdtChartsTwoDimensionalOptions } from "../../config/config";
 import { DesignerConfig } from "../../designer/designerConfig";
-import { LegendBlockModel, Orient, OtherCommonComponents } from "../model";
+import { 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;
+    private twoDimModel;
+    initMargin(designerConfig: DesignerConfig, config: MdtChartsConfig, otherComponents: OtherCommonComponents, data: MdtChartsDataSource, modelInstance: ModelInstance): void;
+    recalcMarginByVerticalAxisLabel(modelInstance: ModelInstance, options: MdtChartsTwoDimensionalOptions, designerConfig: DesignerConfig): void;
+    private recalcMarginByTitle;
 }