mdt-charts 1.12.10 → 1.12.14

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,18 +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 {
-    static initMargin(designerConfig: DesignerConfig, config: MdtChartsConfig, otherComponents: OtherCommonComponents, data: MdtChartsDataSource, modelInstance: ModelInstance): void;
-    static recalcMarginByVerticalAxisLabel(modelInstance: ModelInstance, config: MdtChartsConfig, designerConfig: DesignerConfig, dataScope: DataScope): void;
-    private static getHorizontalMarginByAxisLabels;
-    private static recalcVerticalMarginByAxisLabelHeight;
-    private static recalcHorizontalMarginByAxisLabelWidth;
-    private static recalcMarginWithLegend;
-    private static getLegendItemsContent;
-    static appendToGlobalMarginValuesLegendMargin(canvasModel: CanvasModel, position: Orient, legendBlockModel: LegendBlockModel): void;
-    private static recalcMarginByTitle;
-}

package/lib/model/marginModel.js

@@ -1,110 +0,0 @@
-import { AxisModel } from "./featuresModel/axisModel";
-import { DataManagerModel } from "./dataManagerModel/dataManagerModel";
-import { LegendModel } from "./featuresModel/legendModel/legendModel";
-import { AxisType } from "./modelBuilder";
-import { TwoDimensionalModel } from "./notations/twoDimensionalModel";
-import { keyAxisLabelHorizontalLog, keyAxisLabelVerticalLog } from "./featuresModel/scaleModel/scaleAxisRecalcer";
-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.recalcMarginWithLegend(modelInstance, config, designerConfig.canvas.legendBlock.maxWidth, otherComponents.legendBlock, data);
-        this.recalcMarginByTitle(canvasModel, otherComponents.titleBlock);
-        if (config.options.type === '2d' || config.options.type === 'interval') {
-            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 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 recalcMarginWithLegend(modelInstance, config, legendMaxWidth, legendBlockModel, data) {
-        if (config.options.type === "polar") {
-            return;
-        }
-        const canvasModel = modelInstance.canvasModel;
-        const legendPosition = LegendModel.getLegendModel(config.options.type, config.options.legend.show, modelInstance.canvasModel).position;
-        modelInstance.canvasModel.legendCanvas.setPosition(legendPosition);
-        if (legendPosition !== 'off') {
-            const legendItemsContent = this.getLegendItemsContent(config.options, data);
-            const legendSize = LegendModel.getLegendSize(config.options.type, legendPosition, legendItemsContent, legendMaxWidth, canvasModel.getBlockSize(), legendBlockModel);
-            canvasModel.increaseMarginSide(legendPosition, legendSize);
-            if (legendSize !== 0)
-                this.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
-            legendBlockModel.coordinate[legendPosition].size = legendSize;
-        }
-    }
-    static getLegendItemsContent(options, data) {
-        if (options.type === '2d') {
-            let texts = [];
-            options.charts.forEach(chart => {
-                texts = texts.concat(chart.data.valueFields.map(field => field.title));
-            });
-            return texts;
-        }
-        else if (options.type === 'polar') {
-            return DataManagerModel.getDataValuesByKeyField(data, options.data.dataSource, options.data.keyField.name);
-        }
-        else if (options.type === 'interval') {
-            return [options.chart.data.valueField1.name];
-        }
-    }
-    static appendToGlobalMarginValuesLegendMargin(canvasModel, position, legendBlockModel) {
-        const legendCoordinate = legendBlockModel.coordinate;
-        if (position === 'left' || position === 'right')
-            canvasModel.increaseMarginSide(position, legendCoordinate[position].margin.left + legendCoordinate[position].margin.right);
-        else
-            canvasModel.increaseMarginSide(position, legendCoordinate[position].margin.top + legendCoordinate[position].margin.bottom);
-    }
-    static recalcMarginByTitle(canvasModel, titleBlockModel) {
-        canvasModel.increaseMarginSide("top", titleBlockModel.margin.top + titleBlockModel.size + titleBlockModel.margin.bottom);
-    }
-}

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

@@ -1,11 +0,0 @@
-import { DataScope } from "../model";
-export declare const DEFAULT_MAX_RECORDS_AMOUNT = 50;
-export declare class DataModelInstance {
-    private maxRecordsAmount;
-    private scope;
-    initMaxRecordsAmount(amount: number): void;
-    getMaxRecordsAmount(): number;
-    initScope(scope: DataScope): void;
-    getScope(): DataScope;
-    getAllowableKeys(): string[];
-}

package/lib/model/modelInstance/dataModel.js

@@ -1,23 +0,0 @@
-export const DEFAULT_MAX_RECORDS_AMOUNT = 50;
-export class DataModelInstance {
-    constructor() {
-        this.maxRecordsAmount = DEFAULT_MAX_RECORDS_AMOUNT;
-    }
-    initMaxRecordsAmount(amount) {
-        if (typeof amount === "number" && amount > 0) {
-            this.maxRecordsAmount = amount;
-        }
-    }
-    getMaxRecordsAmount() {
-        return this.maxRecordsAmount;
-    }
-    initScope(scope) {
-        this.scope = scope;
-    }
-    getScope() {
-        return this.scope;
-    }
-    getAllowableKeys() {
-        return this.getScope().allowableKeys;
-    }
-}

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

@@ -1,15 +0,0 @@
-import { MdtChartsDataSource, MdtChartsPolarOptions } from "../../config/config";
-import { DesignerConfig } from "../../designer/designerConfig";
-import { PolarOptionsModel, LegendCoordinate } from "../model";
-import { CanvasModel } from "../modelInstance/canvasModel/canvasModel";
-import { ModelInstance } from "../modelInstance/modelInstance";
-/** If donut block has width less than this const, legend change postion from "right" to "bottom" */
-export declare const MIN_DONUT_BLOCK_SIZE = 120;
-export declare class PolarModel {
-    static getOptions(options: MdtChartsPolarOptions, data: MdtChartsDataSource, designerConfig: DesignerConfig, modelInstance: ModelInstance): PolarOptionsModel;
-    static getLegendPositionByBlockSize(canvasModel: CanvasModel): "bottom" | "right";
-    static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth: number, legendWidth: number, legendCoordinate: LegendCoordinate): boolean;
-    static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight: number, legendCoordinate: LegendCoordinate): boolean;
-    private static getDonutSettings;
-    private static getChartsModel;
-}

package/lib/model/notations/polarModel.js

@@ -1,59 +0,0 @@
-import { ChartStyleModelService } from "../chartStyleModel/chartStyleModel";
-/** If donut block has width less than this const, legend change postion from "right" to "bottom" */
-export const MIN_DONUT_BLOCK_SIZE = 120;
-export class PolarModel {
-    static getOptions(options, data, designerConfig, modelInstance) {
-        return {
-            type: options.type,
-            selectable: !!options.selectable,
-            title: options.title,
-            data: Object.assign({}, options.data),
-            charts: this.getChartsModel(options.chart, data[options.data.dataSource].length, designerConfig.chartStyle),
-            legend: modelInstance.canvasModel.legendCanvas.getModel(),
-            tooltip: options.tooltip,
-            chartCanvas: this.getDonutSettings(designerConfig.canvas.chartOptions.donut, options.chart)
-        };
-    }
-    //TODO: type for returned value
-    static getLegendPositionByBlockSize(canvasModel) {
-        const widthCoefficientWhenLegendShouldInBottom = 1.5;
-        const avgLegendWidth = 100;
-        const blockWidth = canvasModel.getBlockSize().width;
-        const blockHeight = canvasModel.getBlockSize().height;
-        return canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE + avgLegendWidth
-            && blockWidth * widthCoefficientWhenLegendShouldInBottom < blockHeight
-            ? 'bottom'
-            : 'right';
-    }
-    static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth, legendWidth, legendCoordinate) {
-        const rightLegendMargin = legendCoordinate.right.margin;
-        return chartBlockWidth - legendWidth - rightLegendMargin.left - rightLegendMargin.right >= MIN_DONUT_BLOCK_SIZE;
-    }
-    static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight, legendCoordinate) {
-        const minHeightForLegend = 30;
-        const bottomLegendMargin = legendCoordinate.bottom.margin;
-        const heightForLegend = chartBlockHeight - bottomLegendMargin.bottom - bottomLegendMargin.top - MIN_DONUT_BLOCK_SIZE;
-        return heightForLegend >= minHeightForLegend;
-    }
-    static getDonutSettings(settings, chartOptions) {
-        return {
-            padAngle: settings.padAngle,
-            thickness: Object.assign({}, settings.thickness),
-            aggregator: {
-                margin: settings.aggregatorPad,
-                text: chartOptions.aggregator.text
-            }
-        };
-    }
-    static getChartsModel(chart, dataLength, chartStyleConfig) {
-        const chartsModel = [];
-        chartsModel.push({
-            type: chart.type,
-            data: Object.assign({}, chart.data),
-            tooltip: chart.tooltip,
-            cssClasses: ChartStyleModelService.getCssClasses(0),
-            style: ChartStyleModelService.getChartStyle(dataLength, chartStyleConfig)
-        });
-        return chartsModel;
-    }
-}