mdt-charts 1.12.12 → 1.12.16

package/lib/config/config.d.ts

@@ -158,8 +158,8 @@ export interface MdtChartsAggregatorModel {
     data: MdtChartsDataRow[];
 }
 export interface MdtChartsAggregatorContent {
-    value: string | number;
-    title: string;
+    value?: string | number;
+    title?: string;
 }
 interface IntervalChartData {
     valueField1: MdtChartsValueField;

package/lib/engine/contentManager/contentManager.d.ts

@@ -0,0 +1,9 @@
+import { Model } from "../../model/model";
+import Engine from "../engine";
+import { Block } from "../block/block";
+import { MdtChartsDataSource } from "../../config/config";
+export declare class ContentManager {
+    static render(model: Model, engine: Engine): void;
+    static updateData(block: Block, model: Model, newData: MdtChartsDataSource): void;
+    static updateColors(engine: Engine, model: Model): void;
+}

package/lib/engine/contentManager/contentManager.js

@@ -0,0 +1,15 @@
+import { getChartContentManager } from "./contentManagerFactory";
+export class ContentManager {
+    static render(model, engine) {
+        const manager = getChartContentManager(model);
+        manager.render(engine, model);
+    }
+    static updateData(block, model, newData) {
+        const manager = getChartContentManager(model);
+        manager.updateData(block, model, newData);
+    }
+    static updateColors(engine, model) {
+        const manager = getChartContentManager(model);
+        manager.updateColors(engine.block, model);
+    }
+}

package/lib/engine/contentManager/contentManagerFactory.d.ts

@@ -0,0 +1,14 @@
+import { ChartNotation, MdtChartsDataSource } from "../../config/config";
+import { Model } from "../../model/model";
+import { Block } from "../block/block";
+import Engine from "../engine";
+export interface ChartContentManager {
+    render(engine: Engine, model: Model): void;
+    updateData(block: Block, model: Model, newData: MdtChartsDataSource): void;
+    updateColors(block: Block, model: Model): void;
+}
+export declare class ContentManagerFactory {
+    private managers;
+    getManager(type: ChartNotation): ChartContentManager;
+}
+export declare function getChartContentManager(model: Model): ChartContentManager;

package/lib/engine/contentManager/contentManagerFactory.js

@@ -0,0 +1,20 @@
+import { PolarManager } from "../polarNotation/polarManager";
+import { TwoDimensionalManager } from "../twoDimensionalNotation/twoDimensionalManager";
+export class ContentManagerFactory {
+    constructor() {
+        this.managers = {
+            "2d": TwoDimensionalManager,
+            "polar": PolarManager
+        };
+    }
+    getManager(type) {
+        if (type === "interval")
+            return;
+        const managerClass = this.managers[type];
+        return new managerClass();
+    }
+}
+export function getChartContentManager(model) {
+    const factory = new ContentManagerFactory();
+    return factory.getManager(model.options.type);
+}

package/lib/engine/engine.js

@@ -1,6 +1,6 @@
 import { Block } from './block/block';
 import { ValueFormatter } from './valueFormatter';
-import { ContentManager } from './contentManager';
+import { ContentManager } from './contentManager/contentManager';
 import { FilterEventManager } from './filterManager/filterEventManager';
 import { Helper } from './helpers/helper';
 export default class Engine {
@@ -17,7 +17,7 @@ export default class Engine {
         this.block.renderWrapper(model.blockCanvas.size);
         if (model.options) {
             ValueFormatter.setFormatFunction(model.dataSettings.format.formatters);
-            this.renderCharts(model, this.data);
+            this.renderCharts(model);
         }
     }
     updateFullBlock(model, data) {
@@ -48,8 +48,8 @@ export default class Engine {
     updateColors(model) {
         ContentManager.updateColors(this, model);
     }
-    renderCharts(model, data) {
-        ContentManager.render(model, data, this);
+    renderCharts(model) {
+        ContentManager.render(model, this);
     }
     setFilterEventManager(options) {
         var _a, _b, _c;

package/lib/engine/features/tolltip/newTooltip/newTooltip.js

@@ -23,4 +23,4 @@ export class NewTooltip {
             .style('top', coordinate.top);
     }
 }
-NewTooltip.tooltipBlockClass = 'tooltip-block';
+NewTooltip.tooltipBlockClass = 'mdt-charts-tooltip-block';

package/lib/engine/features/tolltip/tooltip.d.ts

@@ -5,10 +5,10 @@ import { Scales } from '../scale/scale';
 import { TooltipSettings } from '../../../designer/designerConfig';
 export declare class Tooltip {
     static readonly tooltipBlockClass: string;
-    static readonly tooltipLineClass = "tooltip-line";
-    static readonly tooltipWrapperClass = "tooltip-wrapper";
-    static readonly tooltipContentClass = "tooltip-content";
-    static readonly tooltipArrowClass = "tooltip-arrow";
+    static readonly tooltipLineClass = "mdt-charts-tooltip-line";
+    static readonly tooltipWrapperClass = "mdt-charts-tooltip-wrapper";
+    static readonly tooltipContentClass = "mdt-charts-tooltip-content";
+    static readonly tooltipArrowClass = "mdt-charts-tooltip-arrow";
     static render(block: Block, model: Model, data: MdtChartsDataSource, tooltipOptions: TooltipSettings, scales?: Scales): void;
     static hide(block: Block): void;
     private static renderTooltipFor2DCharts;

package/lib/engine/features/tolltip/tooltip.js

@@ -175,7 +175,7 @@ export class Tooltip {
     }
 }
 Tooltip.tooltipBlockClass = NewTooltip.tooltipBlockClass;
-Tooltip.tooltipLineClass = 'tooltip-line';
-Tooltip.tooltipWrapperClass = 'tooltip-wrapper';
-Tooltip.tooltipContentClass = 'tooltip-content';
-Tooltip.tooltipArrowClass = 'tooltip-arrow';
+Tooltip.tooltipLineClass = 'mdt-charts-tooltip-line';
+Tooltip.tooltipWrapperClass = 'mdt-charts-tooltip-wrapper';
+Tooltip.tooltipContentClass = 'mdt-charts-tooltip-content';
+Tooltip.tooltipArrowClass = 'mdt-charts-tooltip-arrow';

package/lib/engine/polarNotation/polarManager.d.ts

@@ -2,9 +2,10 @@ import { Model } from "../../model/model";
 import { Block } from "../block/block";
 import Engine from "../engine";
 import { MdtChartsDataSource } from "../../config/config";
-export declare class PolarManager {
-    static render(engine: Engine, model: Model): void;
-    static update(block: Block, model: Model, data: MdtChartsDataSource): void;
-    static updateColors(block: Block, model: Model): void;
-    private static renderCharts;
+import { ChartContentManager } from "../contentManager/contentManagerFactory";
+export declare class PolarManager implements ChartContentManager {
+    render(engine: Engine, model: Model): void;
+    updateData(block: Block, model: Model, data: MdtChartsDataSource): void;
+    updateColors(block: Block, model: Model): void;
+    private renderCharts;
 }

package/lib/engine/polarNotation/polarManager.js

@@ -6,7 +6,7 @@ import { Aggregator } from "../features/aggregator/aggregator";
 import { Donut } from "./donut/donut";
 import { PolarRecordOverflowAlert } from "./extenders/polarRecordOverflowAlert";
 export class PolarManager {
-    static render(engine, model) {
+    render(engine, model) {
         const options = model.options;
         engine.block.renderSvg(model.blockCanvas.size);
         this.renderCharts(engine.block, options.charts, engine.data, options.data.dataSource, model.chartBlock.margin, model.blockCanvas.size, options.chartCanvas);
@@ -25,7 +25,7 @@ export class PolarManager {
                 engine.block.filterEventManager.clearKeysForPolar(model.chartBlock.margin, model.blockCanvas.size, options);
         });
     }
-    static update(block, model, data) {
+    updateData(block, model, data) {
         block.transitionManager.interruptTransitions();
         block.removeMouseEvents();
         block.filterEventManager.updateData(data[model.options.data.dataSource]);
@@ -46,11 +46,11 @@ export class PolarManager {
             legendPosition: model.options.legend.position
         });
     }
-    static updateColors(block, model) {
+    updateColors(block, model) {
         Legend.updateColors(block, model.options);
         Donut.updateColors(block, model.options.charts[0]);
     }
-    static renderCharts(block, charts, data, dataSource, margin, blockSize, donutSettings) {
+    renderCharts(block, charts, data, dataSource, margin, blockSize, donutSettings) {
         charts.forEach((chart) => {
             if (chart.type === 'donut')
                 Donut.render(block, data[dataSource], margin, chart, blockSize, donutSettings);

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

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

package/lib/engine/twoDimensionalNotation/twoDimensionalManager.js

@@ -14,7 +14,7 @@ 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;
@@ -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,7 +74,7 @@ export class TwoDimensionalManager {
                 Area.updateColors(block, chart);
         });
     }
-    static renderCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, barSettings, blockSize) {
+    renderCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, barSettings, blockSize) {
         block.renderChartClipPath(margin, blockSize);
         block.renderChartsBlock();
         charts.forEach((chart) => {
@@ -87,7 +87,7 @@ export class TwoDimensionalManager {
         });
         EmbeddedLabels.raiseGroups(block);
     }
-    static updateCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, blockSize, barSettings) {
+    updateCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, blockSize, barSettings) {
         block.updateChartClipPath(margin, blockSize);
         let promises = [];
         charts.forEach((chart) => {

package/lib/model/dataManagerModel/dataManagerModel.js

@@ -54,6 +54,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 +72,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/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

@@ -10,12 +10,12 @@ export class LegendModel {
                 },
                 bottom: {
                     size: 0,
-                    margin: { top: 5, bottom: 20, left: 0, right: 0 },
+                    margin: { top: 10, bottom: 20, left: 0, right: 0 },
                     pad: 0
                 },
                 right: {
                     size: 0,
-                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 10, right: 0 },
+                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 15, right: 0 },
                     pad: 0
                 },
                 top: {
@@ -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/scaleAxisRecalcer.js

@@ -19,7 +19,9 @@ export class ScaleAxisRecalcer {
                 : canvasModel.getChartBlockWidth()) - scaleValueFn(0));
         const key = chartOrientation === "vertical" ? keyAxisLabelVerticalLog : keyAxisLabelHorizontalLog;
         const logInfo = canvasModel.marginService.getDataByKey(key);
-        canvasModel.decreaseMarginSide(logInfo.side, logInfo.byValue - coordinateOnChartBlock < 0 ? logInfo.byValue : coordinateOnChartBlock);
+        if (logInfo) {
+            canvasModel.decreaseMarginSide(logInfo.side, logInfo.byValue - coordinateOnChartBlock < 0 ? logInfo.byValue : coordinateOnChartBlock);
+        }
     }
     getScaleValue() {
         const scale = this.generateScaleLinear();

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;
+}