mdt-charts 1.12.11 → 1.12.15

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

@@ -1,186 +0,0 @@
-import { NewTooltipServiceClass } from "./newTooltipService";
-const ignoredValue = 0;
-const ignoredBigvalue = 1000000;
-describe('newTooltipService', () => {
-    const getIgnoredSize = (big) => {
-        return {
-            height: big ? ignoredBigvalue : ignoredValue,
-            width: big ? ignoredBigvalue : ignoredValue
-        };
-    };
-    const getSizeWithOne = (key, value) => {
-        const size = getIgnoredSize();
-        size[key] = value;
-        return size;
-    };
-    const getPosWithOne = (key, value) => {
-        const coordinate = {
-            left: ignoredValue,
-            top: ignoredValue
-        };
-        coordinate[key] = value;
-        return coordinate;
-    };
-    const getBoundingWithOne = (key, value) => {
-        const blockBounding = {
-            left: ignoredValue,
-            bottom: ignoredValue,
-            height: ignoredValue,
-            top: ignoredValue,
-            width: ignoredValue
-        };
-        blockBounding[key] = value;
-        return blockBounding;
-    };
-    const service = new NewTooltipServiceClass();
-    describe('getTooltipByWindow with parentBlock', () => {
-        test('should return left point equal to `-(left of parent block)` if left of tooltip is less', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("left", -50);
-            const windowSize = getIgnoredSize(true);
-            const blockBounding = getBoundingWithOne("left", 10);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.left).toBe(-blockBounding.left);
-        });
-        test('should return left point equal to left of preCoordinate if left of tooltip is less', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("left", 20);
-            const windowSize = getIgnoredSize(true);
-            const blockBounding = getBoundingWithOne("left", 10);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.left).toBe(preCoordinate.left);
-        });
-        test('should return left point equal to `(window width - tooltip width)` if right of tooltip is bigger', () => {
-            const tooltipBounding = getSizeWithOne("width", 50);
-            const preCoordinate = getPosWithOne("left", 20);
-            const windowSize = getSizeWithOne("width", 90);
-            const blockBounding = getBoundingWithOne("left", 30);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.left).toBe(-8); // 50 + 20 + 30 > 90 => 90 - 30 - 50 - scrollPad(18)
-        });
-        test('should return left point equal to left of preCoordinate if right of tooltip is less than window width', () => {
-            const tooltipBounding = getSizeWithOne("width", 50);
-            const preCoordinate = getPosWithOne("left", 20);
-            const windowSize = getSizeWithOne("width", 200);
-            const blockBounding = getBoundingWithOne("left", 30);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.left).toBe(preCoordinate.left); // 50 + 20 + 30 < 200
-        });
-        test('should return top point equal to `-(top of parent block)` if top of tooltip is less', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("top", -40);
-            const windowSize = getIgnoredSize(true);
-            const blockBounding = getBoundingWithOne("top", -20);
-            let res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(-blockBounding.top);
-            blockBounding.top = -60;
-            res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(-blockBounding.top); // 60 by blockBounding = 0 by window
-            blockBounding.top = -100;
-            preCoordinate.top = 20;
-            res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(-blockBounding.top);
-            blockBounding.top = -10;
-            preCoordinate.top = 5;
-            res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(-blockBounding.top);
-        });
-        test('should return top point equal top of preCoordinate if top of tooltip is bigger', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("top", 20);
-            const windowSize = getIgnoredSize(true);
-            const blockBounding = getBoundingWithOne("top", 100);
-            let res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(preCoordinate.top);
-            preCoordinate.top = -99;
-            res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(preCoordinate.top);
-        });
-        test('should return top point equal to `(winHeight - tooltipHeight)` if bottom of tooltip is bigger than window height', () => {
-            const tooltipBounding = getSizeWithOne("height", 50);
-            const preCoordinate = getPosWithOne("top", 90);
-            const windowSize = getSizeWithOne("height", 200);
-            const blockBounding = {
-                left: ignoredValue,
-                bottom: 210,
-                height: 110,
-                top: 100,
-                width: ignoredValue
-            };
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(50); // 110 - 50 - (210 - 200)
-        });
-        test('should return top point equal to top of preCoordinate if bottom of tooltip is less than height of window', () => {
-            const tooltipBounding = getSizeWithOne("height", 50);
-            const preCoordinate = getPosWithOne("top", 90);
-            const windowSize = getSizeWithOne("height", 300);
-            const blockBounding = {
-                left: ignoredValue,
-                bottom: 210,
-                height: 110,
-                top: 100,
-                width: ignoredValue
-            };
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(preCoordinate.top); // 90 + 50 + 100 < 300
-        });
-    });
-    describe('getTooltipByWindow without parentBlock', () => {
-        test('should return left point equal to 0 if left of tooltip is less', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("left", -50);
-            const windowSize = getIgnoredSize(true);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.left === 0).toBe(true); // negative zero jest not matching with simple zero
-        });
-        test('should return left point equal to left of preCoordinate if left of tooltip is bigger than 0', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("left", 20);
-            const windowSize = getIgnoredSize(true);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.left).toBe(preCoordinate.left);
-        });
-        test('should return left point equal to `(window width - tooltip width)` if right of tooltip is bigger', () => {
-            const tooltipBounding = getSizeWithOne("width", 50);
-            const preCoordinate = getPosWithOne("left", 60);
-            const windowSize = getSizeWithOne("width", 100);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.left).toBe(32); // 60 + 50 > 100 => 100 - 50 - scrollPad(18)
-        });
-        test('should return left point equal to left of preCoordinate if right of tooltip is less than window width', () => {
-            const tooltipBounding = getSizeWithOne("width", 50);
-            const preCoordinate = getPosWithOne("left", 20);
-            const windowSize = getSizeWithOne("width", 200);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.left).toBe(preCoordinate.left); // 50 + 20 < 200
-        });
-        test('should return top point equal to 0 if top of tooltip is less than 0', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("top", -40);
-            const windowSize = getIgnoredSize(true);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.top === 0).toBe(true);
-        });
-        test('should return top point equal top of preCoordinate if top of tooltip is bigger than 0', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("top", 20);
-            const windowSize = getIgnoredSize(true);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.top).toBe(preCoordinate.top);
-        });
-        test('should return top point equal to `(winHeight - tooltipHeight)` if bottom of tooltip is bigger than window height', () => {
-            const tooltipBounding = getSizeWithOne("height", 50);
-            const preCoordinate = getPosWithOne("top", 90);
-            const windowSize = getSizeWithOne("height", 100);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.top).toBe(50); // 90 + 50 > 100 => 100 - 50
-        });
-        test('should return top point equal to top of preCoordinate if bottom of tooltip is less than height of window', () => {
-            const tooltipBounding = getSizeWithOne("height", 50);
-            const preCoordinate = getPosWithOne("top", 90);
-            const windowSize = getSizeWithOne("height", 300);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.top).toBe(preCoordinate.top); // 90 + 50 < 300
-        });
-    });
-});

package/lib/engine/twoDimensionalNotation/bar/stackedData/dataStacker.test.js

@@ -1,199 +0,0 @@
-import { DataStacker } from "./dataStacker";
-import { DataStackerService } from "./dataStackerService";
-describe('DataStacker', () => {
-    const stacker = new DataStacker();
-    describe('getStackedData', () => {
-        describe('for positive values', () => {
-            let dataRows = [
-                { price: 12, count: 30 },
-                { price: 30, count: 12 },
-                { price: 0, count: 100 },
-                { price: 10, count: 0 }
-            ];
-            const valueFields = ["price", "count"];
-            test('should return right stack', () => {
-                const res = stacker.getStackedData(dataRows, valueFields);
-                expect(res).toEqual([
-                    [
-                        { "0": 0, "1": 12, data: dataRows[0] },
-                        { "0": 0, "1": 30, data: dataRows[1] },
-                        { "0": 0, "1": 0, data: dataRows[2] },
-                        { "0": 0, "1": 10, data: dataRows[3] },
-                    ],
-                    [
-                        { "0": 12, "1": 42, data: dataRows[0] },
-                        { "0": 30, "1": 42, data: dataRows[1] },
-                        { "0": 0, "1": 100, data: dataRows[2] },
-                        { "0": 10, "1": 10, data: dataRows[3] },
-                    ]
-                ]);
-            });
-        });
-        describe('for negative values', () => {
-            let dataRows = [
-                { price: -12, count: -30 },
-                { price: -30, count: -12 },
-                { price: 0, count: -100 },
-                { price: -10, count: 0 }
-            ];
-            const valueFields = ["price", "count"];
-            test('should return right stack', () => {
-                const res = stacker.getStackedData(dataRows, valueFields);
-                expect(res).toEqual([
-                    [
-                        { "0": 0, "1": -12, data: dataRows[0] },
-                        { "0": 0, "1": -30, data: dataRows[1] },
-                        { "0": 0, "1": 0, data: dataRows[2] },
-                        { "0": 0, "1": -10, data: dataRows[3] },
-                    ],
-                    [
-                        { "0": -12, "1": -42, data: dataRows[0] },
-                        { "0": -30, "1": -42, data: dataRows[1] },
-                        { "0": 0, "1": -100, data: dataRows[2] },
-                        { "0": -10, "1": -10, data: dataRows[3] },
-                    ]
-                ]);
-            });
-        });
-    });
-});
-describe('DataStackerService', () => {
-    const service = new DataStackerService();
-    let data = [
-        [
-            { "0": 0, "1": 42, data: {} },
-            { "0": 0, "1": -123, data: {} }
-        ]
-    ];
-    describe('getLastValue', () => {
-        test('should return 0 if vfIndex is 0', () => {
-            const res = service.getValue0(data, 0, 0, 0);
-            expect(res).toBe(0);
-        });
-        test('should return last positive values if positive value exists and need positive', () => {
-            const res = service.getValue0(data, 1, 0, 12);
-            expect(res).toBe(42);
-        });
-        test('should return 0 if positive value not exists and need positive', () => {
-            const res = service.getValue0(data, 1, 1, 12);
-            expect(res).toBe(0);
-        });
-        test('should return last negative value if negative value exists and need negative', () => {
-            const res = service.getValue0(data, 1, 1, -12);
-            expect(res).toBe(-123);
-        });
-        test('should return 0 if negative value not exists and need negative', () => {
-            const res = service.getValue0(data, 1, 0, -12);
-            expect(res).toBe(0);
-        });
-    });
-    describe('getValue1', () => {
-        test('should return sum of value0 + value from data', () => {
-            let res = service.getValue1(0, 12);
-            expect(res).toBe(12);
-            res = service.getValue1(-12, -30);
-            expect(res).toBe(-42);
-            res = service.getValue1(0, 30);
-            expect(res).toBe(30);
-            res = service.getValue1(0, -30);
-            expect(res).toBe(-30);
-        });
-    });
-});
-describe('real example (positive only)', () => {
-    const stacker = new DataStacker();
-    const data = [
-        {
-            $id: 1,
-            brand: "BMW BMW",
-            price: 100000,
-            count: 12000,
-            color: "red"
-        },
-        {
-            $id: 2,
-            brand: "LADA",
-            price: 0,
-            count: 1000,
-            color: "green"
-        },
-        {
-            $id: 3,
-            brand: "MERCEDES",
-            price: 15000,
-            count: 1200,
-            color: "blue"
-        },
-        {
-            $id: 4,
-            brand: "AUDI",
-            price: 20000,
-            count: 500,
-            color: "yellow"
-        },
-        {
-            $id: 5,
-            brand: "VOLKSWAGEN",
-            price: 115000,
-            count: 6000,
-            color: "cyan"
-        },
-        {
-            $id: 6,
-            brand: "DODGE",
-            price: 115000,
-            count: 4000,
-            color: "red"
-        },
-        {
-            $id: 7,
-            brand: "SAAB",
-            price: 50000,
-            count: 11000,
-            color: "orange"
-        },
-        {
-            $id: 8,
-            brand: "HONDA",
-            price: 20000,
-            count: 2000,
-            color: "brown"
-        },
-        {
-            $id: 9,
-            brand: "TOYOTA",
-            price: 40000,
-            count: 15000,
-            color: "pink"
-        }
-    ];
-    const valueFields = ["price", "count"];
-    const stackedData = [
-        [
-            { "0": 0, "1": 100000, data: data[0] },
-            { "0": 0, "1": 0, data: data[1] },
-            { "0": 0, "1": 15000, data: data[2] },
-            { "0": 0, "1": 20000, data: data[3] },
-            { "0": 0, "1": 115000, data: data[4] },
-            { "0": 0, "1": 115000, data: data[5] },
-            { "0": 0, "1": 50000, data: data[6] },
-            { "0": 0, "1": 20000, data: data[7] },
-            { "0": 0, "1": 40000, data: data[8] }
-        ],
-        [
-            { "0": 100000, "1": 112000, data: data[0] },
-            { "0": 0, "1": 1000, data: data[1] },
-            { "0": 15000, "1": 16200, data: data[2] },
-            { "0": 20000, "1": 20500, data: data[3] },
-            { "0": 115000, "1": 121000, data: data[4] },
-            { "0": 115000, "1": 119000, data: data[5] },
-            { "0": 50000, "1": 61000, data: data[6] },
-            { "0": 20000, "1": 22000, data: data[7] },
-            { "0": 40000, "1": 55000, data: data[8] }
-        ]
-    ];
-    test('check on real example', () => {
-        const res = stacker.getStackedData(data, valueFields);
-        expect(res).toEqual(stackedData);
-    });
-});

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

@@ -1,19 +0,0 @@
-import { ScaleKeyModel, ScaleKeyType, ScaleValueModel, ScaleValueType } from "../model";
-import { AxisPosition, NumberDomain, IntervalChart, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions, ChartOrientation, MdtChartsDataSource, 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, data: MdtChartsDataSource, canvasModel: CanvasModel): ScaleValueModel;
-    static getRangePeek(scaleType: ScaleType, chartOrientation: string, canvasModel: CanvasModel): number;
-    static getDateValueDomain(data: MdtChartsDataSource, chart: IntervalChart, keyAxisPosition: AxisPosition, dataSource: string): [Date, Date];
-    static getLinearDomain(configDomain: NumberDomain, data: MdtChartsDataSource, configOptions: 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;
-}

package/lib/model/featuresModel/scaleModel.js

@@ -1,115 +0,0 @@
-import { ModelHelper } from "../modelHelper";
-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) {
-        return {
-            domain: allowableKeys,
-            range: {
-                start: 0,
-                end: ScaleModel.getRangePeek(ScaleType.Key, orient, canvasModel)
-            },
-            type: ScaleModel.getScaleKeyType(charts),
-            elementsAmount: this.getElementsAmount(barCharts)
-        };
-    }
-    static getScaleLinear(options, data, canvasModel) {
-        return {
-            domain: ScaleModel.getLinearDomain(options.axis.value.domain, data, options),
-            range: {
-                start: 0,
-                end: ScaleModel.getRangePeek(ScaleType.Value, options.orientation, canvasModel)
-            },
-            type: ScaleModel.getScaleValueType(options.charts)
-        };
-    }
-    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, data, configOptions) {
-        let domainPeekMin;
-        let domainPeekMax;
-        if (configDomain.start === -1)
-            domainPeekMin = this.getScaleMinValue(configOptions.charts, data[configOptions.data.dataSource]);
-        else
-            domainPeekMin = configDomain.start;
-        if (configDomain.end === -1)
-            domainPeekMax = this.getScaleMaxValue(configOptions.charts, data[configOptions.data.dataSource]);
-        else
-            domainPeekMax = configDomain.end;
-        if (configOptions.axis.key.position === 'start')
-            return [domainPeekMin, domainPeekMax];
-        return [domainPeekMax, domainPeekMin];
-    }
-    static 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)
-                        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 (dataRow[field.name] < sumInRow)
-                        sumInRow = dataRow[field.name];
-                });
-                if (min > sumInRow)
-                    min = sumInRow;
-            });
-        });
-        return min;
-    }
-}

package/lib/model/marginModel.d.ts

@@ -1,17 +0,0 @@
-import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
-import { DesignerConfig } from "../designer/designerConfig";
-import { DataScope, LegendBlockModel, Orient, OtherCommonComponents } from "./model";
-import { ModelInstance } from "./modelInstance/modelInstance";
-import { CanvasModel } from "./modelInstance/canvasModel/canvasModel";
-export declare const AXIS_HORIZONTAL_LABEL_PADDING = 15;
-export declare const AXIS_VERTICAL_LABEL_PADDING = 10;
-export declare class MarginModel {
-    private static twoDimLegendModel;
-    static initMargin(designerConfig: DesignerConfig, config: MdtChartsConfig, otherComponents: OtherCommonComponents, data: MdtChartsDataSource, modelInstance: ModelInstance): void;
-    static recalcMarginByVerticalAxisLabel(modelInstance: ModelInstance, config: MdtChartsConfig, designerConfig: DesignerConfig, dataScope: DataScope): void;
-    static appendToGlobalMarginValuesLegendMargin(canvasModel: CanvasModel, position: Orient, legendBlockModel: LegendBlockModel): void;
-    private static getHorizontalMarginByAxisLabels;
-    private static recalcVerticalMarginByAxisLabelHeight;
-    private static recalcHorizontalMarginByAxisLabelWidth;
-    private static recalcMarginByTitle;
-}

package/lib/model/marginModel.js

@@ -1,80 +0,0 @@
-import { AxisModel } from "./featuresModel/axisModel";
-import { DataManagerModel } from "./dataManagerModel/dataManagerModel";
-import { AxisType } from "./modelBuilder";
-import { TwoDimensionalModel } from "./notations/twoDimensionalModel";
-import { keyAxisLabelHorizontalLog, keyAxisLabelVerticalLog } from "./featuresModel/scaleModel/scaleAxisRecalcer";
-import { TwoDimLegendModel } from "./featuresModel/legendModel/twoDimLegendModel";
-export const AXIS_HORIZONTAL_LABEL_PADDING = 15;
-export const AXIS_VERTICAL_LABEL_PADDING = 10;
-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') {
-            this.twoDimLegendModel.recalcMarginWith2DLegend(modelInstance, otherComponents.legendBlock);
-            const labelSize = this.getHorizontalMarginByAxisLabels(designerConfig.canvas.axisLabel.maxSize.main, config.options.axis, data, config.options);
-            this.recalcVerticalMarginByAxisLabelHeight(labelSize, canvasModel, config.options.orientation, config.options.axis);
-            // Если встроенный лейбл показывает ключи, то лейблы оси ключей не показываются
-            // При этом все графики должны иметь: embeddedLabels = 'key'
-            // И все графики должны быть типа bar. 
-            const showingFlag = config.options.type === '2d'
-                ? !TwoDimensionalModel.getChartsEmbeddedLabelsFlag(config.options.charts, config.options.orientation)
-                : true;
-            this.recalcHorizontalMarginByAxisLabelWidth(labelSize, canvasModel, config.options.orientation, config.options.axis, showingFlag);
-        }
-    }
-    static recalcMarginByVerticalAxisLabel(modelInstance, config, designerConfig, dataScope) {
-        if ((config.options.type === '2d' || config.options.type === 'interval') && config.options.orientation === 'vertical') {
-            const axisLabelSize = AxisModel.getLabelSize(designerConfig.canvas.axisLabel.maxSize.main, dataScope.allowableKeys);
-            const axisConfig = AxisModel.getKeyAxisLabelPosition(modelInstance.canvasModel, dataScope.allowableKeys.length, config.options.axis.key);
-            const marginOrient = config.options.axis.key.position === 'end' ? 'bottom' : 'top';
-            if (axisConfig === 'rotated') {
-                modelInstance.canvasModel.decreaseMarginSide(marginOrient, axisLabelSize.height);
-                modelInstance.canvasModel.increaseMarginSide(marginOrient, axisLabelSize.width, keyAxisLabelVerticalLog);
-            }
-        }
-    }
-    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 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);
-    }
-    static 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);
-    }
-    static 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);
-        }
-    }
-    static recalcMarginByTitle(canvasModel, titleBlockModel) {
-        canvasModel.increaseMarginSide("top", titleBlockModel.margin.top + titleBlockModel.size + titleBlockModel.margin.bottom);
-    }
-}
-MarginModel.twoDimLegendModel = new TwoDimLegendModel();

package/lib/model/modelHelper.d.ts

@@ -1,7 +0,0 @@
-import { MdtChartsDataSource, IntervalChart } from "../config/config";
-export declare class ModelHelper {
-    static getSum(items: number[]): number;
-    static getMinAndMaxOfIntervalData(data: MdtChartsDataSource, dataSource: string, chart: IntervalChart): [Date, Date];
-    static getUniqueValues(values: string[]): string[];
-    static getStringScore(word: string): number;
-}

package/lib/model/modelHelper.js

@@ -1,41 +0,0 @@
-export class ModelHelper {
-    static getSum(items) {
-        return items.reduce((acc, item) => acc + item, 0);
-    }
-    static getMinAndMaxOfIntervalData(data, dataSource, chart) {
-        let min = data[dataSource][0][chart.data.valueField1.name];
-        let max = data[dataSource][0][chart.data.valueField1.name];
-        const chartData = data[dataSource];
-        const valueField1 = chart.data.valueField1.name;
-        const valueField2 = chart.data.valueField2.name;
-        chartData.forEach(dataRow => {
-            if (dataRow[valueField1] > max)
-                max = dataRow[valueField1];
-            if (dataRow[valueField1] < min)
-                min = dataRow[valueField1];
-            if (dataRow[valueField2] > max)
-                max = dataRow[valueField2];
-            if (dataRow[valueField2] < min)
-                min = dataRow[valueField2];
-        });
-        return [min, max];
-    }
-    static getUniqueValues(values) {
-        const uniqueValues = values.filter((keyValue, index, self) => self.indexOf(keyValue) === index);
-        return uniqueValues;
-    }
-    static getStringScore(word) {
-        // lower case letter width ~ 0.74 from upper case width.
-        // Number width == lower case letter width
-        let score = 0;
-        const upperLetterScore = 1;
-        const lowerLetterScore = 0.74;
-        for (let i = 0; i < word.length; i++) {
-            if (word[i].toUpperCase() === word[i] && parseFloat(word[i]).toString() !== word[i])
-                score += upperLetterScore;
-            else
-                score += lowerLetterScore;
-        }
-        return score;
-    }
-}