mdt-charts 1.9.7 → 1.9.11

package/lib/model/dataManagerModel.js

@@ -1,137 +0,0 @@
-import { AxisModel } from "./featuresModel/axisModel";
-import { LegendCanvasModel } from "./featuresModel/legendModel/legendCanvasModel";
-import { MIN_DONUT_BLOCK_SIZE } from "./featuresModel/legendModel/legendModel";
-import { ModelHelper } from "./modelHelper";
-export class DataManagerModel {
-    static getPreparedData(data, allowableKeys, config) {
-        const scopedData = this.getScopedData(data, allowableKeys, config);
-        this.setDataType(scopedData, config);
-        return scopedData;
-    }
-    static getDataScope(config, margin, data, designerConfig, legendBlock) {
-        if (config.options.type === '2d' || config.options.type === 'interval') {
-            return this.getDataScopeFor2D(config.options, config.canvas.size, margin, data, designerConfig);
-        }
-        else if (config.options.type === 'polar') {
-            return this.getDataScopeForPolar(config.options, config.canvas.size, margin, data, legendBlock, designerConfig.canvas.legendBlock);
-        }
-    }
-    static getDataValuesByKeyField(data, dataSourceName, keyFieldName) {
-        return data[dataSourceName].map(dataRow => dataRow[keyFieldName]);
-    }
-    static getDataScopeFor2D(configOptions, blockSize, margin, data, designerConfig) {
-        // Для interval всегда один элемент, так как там может быть только один столбик
-        let itemsLength = 1;
-        if (configOptions.type === '2d') {
-            itemsLength = (configOptions.charts)
-                .filter((chart) => chart.type === 'bar').length;
-            if (itemsLength === 0)
-                itemsLength = 1; // Если баров нет, то для одной записи выделяется столько же места, сколько для одного столбика
-        }
-        if (itemsLength !== 0) {
-            const axisLength = AxisModel.getAxisLength(configOptions.orientation, margin, blockSize);
-            const uniqueKeys = ModelHelper.getUniqueValues(data[configOptions.data.dataSource].map(d => d[configOptions.data.keyField.name]));
-            const dataLength = uniqueKeys.length;
-            const limit = this.getDataLimitByItemSize(this.getElementsInGroupAmount(configOptions, itemsLength), dataLength, axisLength, designerConfig.canvas.chartOptions.bar);
-            const allowableKeys = uniqueKeys.slice(0, limit);
-            return {
-                allowableKeys,
-                hidedRecordsAmount: dataLength - allowableKeys.length
-            };
-        }
-        return {
-            allowableKeys: this.getDataValuesByKeyField(data, configOptions.data.dataSource, configOptions.data.keyField.name),
-            hidedRecordsAmount: 0
-        };
-    }
-    static getDataScopeForPolar(configOptions, blockSize, margin, data, legendBlock, legendCanvas) {
-        const dataset = data[configOptions.data.dataSource];
-        const keyFieldName = configOptions.data.keyField.name;
-        const keys = dataset.map(dataRow => dataRow[keyFieldName]);
-        if (!configOptions.legend.show) {
-            return {
-                allowableKeys: keys,
-                hidedRecordsAmount: 0
-            };
-        }
-        let position;
-        if (blockSize.width - margin.left - margin.right >= MIN_DONUT_BLOCK_SIZE)
-            position = 'right';
-        else
-            position = 'bottom';
-        let maxItemsNumber;
-        if (position === 'right') {
-            maxItemsNumber = LegendCanvasModel.findElementsAmountByLegendSize(keys, position, legendCanvas.maxWidth, blockSize.height - margin.top - margin.bottom);
-        }
-        else {
-            let marginBottom = margin.bottom - (legendBlock.coordinate.bottom.size === 0 ? legendBlock.coordinate.bottom.size : legendBlock.coordinate.bottom.size - legendBlock.coordinate.bottom.margin.bottom);
-            maxItemsNumber = LegendCanvasModel.findElementsAmountByLegendSize(keys, position, blockSize.width - margin.left - margin.right, blockSize.height - margin.top - marginBottom - legendBlock.coordinate.bottom.margin.bottom - MIN_DONUT_BLOCK_SIZE);
-        }
-        return {
-            allowableKeys: keys.slice(0, maxItemsNumber),
-            hidedRecordsAmount: keys.length - maxItemsNumber
-        };
-    }
-    /**
-     * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
-     * @param configOptions
-     * @param chartsLength
-     */
-    static getElementsInGroupAmount(configOptions, chartsLength) {
-        if (configOptions.type === '2d')
-            return this.getBarChartsInGroupAmount(configOptions.charts);
-        return chartsLength;
-    }
-    static getBarChartsInGroupAmount(charts) {
-        let barsAmount = 0;
-        charts.forEach(chart => {
-            if (chart.type === 'bar' && chart.isSegmented)
-                barsAmount += 1; // в сегментированном баре все valueFields находятся внутри одного бара, поэтому бар всегда один.
-            else if (chart.type === 'bar')
-                barsAmount += chart.data.valueFields.length;
-        });
-        return barsAmount;
-    }
-    static getScopedData(data, allowableKeys, config) {
-        const newData = {};
-        newData[config.options.data.dataSource] = this.getScopedChartData(data[config.options.data.dataSource], allowableKeys, config.options.data.keyField.name);
-        return newData;
-    }
-    static getScopedChartData(data, allowableKeys, keyFieldName) {
-        return data.filter(d => allowableKeys.findIndex(key => key === d[keyFieldName]) !== -1);
-    }
-    static setDataType(data, config) {
-        if (config.options.type === 'polar' || config.options.type === '2d') {
-            // Форматиривание для оси ключей пока не совсем верно установлено
-            // if(config.options.data.keyField.format === 'date') {
-            //     data[config.options.data.dataSource] = this.getTypedData(data[config.options.data.dataSource], config.options.data.keyField);
-            // }
-        }
-        else if (config.options.type === 'interval') {
-            const chart = config.options.chart;
-            if (chart.data.valueField1.format === 'date') {
-                data[config.options.data.dataSource] = this.getTypedData(data[config.options.data.dataSource], chart.data.valueField1);
-            }
-            if (chart.data.valueField2.format === 'date') {
-                data[config.options.data.dataSource] = this.getTypedData(data[config.options.data.dataSource], chart.data.valueField2);
-            }
-        }
-    }
-    static getTypedData(data, field) {
-        if (field.format === 'date')
-            data.forEach(d => {
-                d[field.name] = new Date(d[field.name]);
-            });
-        return data;
-    }
-    static getDataLimitByItemSize(elementsInGroupAmount, dataLength, axisLength, barOptions) {
-        let sumSize = dataLength * (elementsInGroupAmount * barOptions.minBarWidth + (elementsInGroupAmount - 1) * barOptions.barDistance + barOptions.groupMinDistance);
-        while (dataLength !== 0 && axisLength < sumSize) {
-            dataLength--;
-            // find whole space for bars in group + distance between bars + group distance
-            sumSize = dataLength * (elementsInGroupAmount * barOptions.minBarWidth + (elementsInGroupAmount - 1)
-                * barOptions.barDistance + barOptions.groupMinDistance);
-        }
-        return dataLength;
-    }
-}

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

@@ -1,18 +0,0 @@
-import { AxisPosition, ChartOrientation, DataOptions, MdtChartsDataSource, DiscreteAxisOptions, NumberAxisOptions, Size, TwoDimensionalChart } from "../../config/config";
-import { AxisLabelPosition, AxisModelOptions, BlockMargin, Orient } from "../model";
-import { AxisType } from "../modelBuilder";
-import { AxisLabelCanvas, TooltipSettings } from "../../designer/designerConfig";
-export interface LabelSize {
-    width: number;
-    height: number;
-}
-export declare class AxisModel {
-    static getKeyAxis(charts: TwoDimensionalChart[], data: MdtChartsDataSource, dataOptions: DataOptions, orient: ChartOrientation, axisConfig: DiscreteAxisOptions, labelConfig: AxisLabelCanvas, margin: BlockMargin, blockSize: Size, tooltipSettings: TooltipSettings): AxisModelOptions;
-    static getValueAxis(orient: ChartOrientation, axisConfig: NumberAxisOptions, labelConfig: AxisLabelCanvas, margin: BlockMargin, blockSize: Size): AxisModelOptions;
-    static getAxisLength(chartOrientation: ChartOrientation, margin: BlockMargin, blockSize: Size): number;
-    static getAxisOrient(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition): Orient;
-    static getAxisTranslateX(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition, margin: BlockMargin, blockWidth: number): number;
-    static getAxisTranslateY(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition, margin: BlockMargin, blockHeight: number): number;
-    static getKeyAxisLabelPosition(margin: BlockMargin, blockSize: Size, scopedDataLength: number): AxisLabelPosition;
-    static getLabelSize(labelMaxWidth: number, labelTexts: any[]): LabelSize;
-}

package/lib/model/featuresModel/axisModel.js

@@ -1,111 +0,0 @@
-import { ModelHelper } from "../modelHelper";
-import { AxisType, CLASSES } from "../modelBuilder";
-import { DataManagerModel } from "../dataManagerModel";
-import { TwoDimensionalModel } from "../notations/twoDimensionalModel";
-export class AxisModel {
-    static getKeyAxis(charts, data, dataOptions, orient, axisConfig, labelConfig, margin, blockSize, tooltipSettings) {
-        return {
-            type: 'key',
-            orient: AxisModel.getAxisOrient(AxisType.Key, orient, axisConfig.position),
-            translate: {
-                translateX: AxisModel.getAxisTranslateX(AxisType.Key, orient, axisConfig.position, margin, blockSize.width),
-                translateY: AxisModel.getAxisTranslateY(AxisType.Key, orient, axisConfig.position, margin, blockSize.height)
-            },
-            cssClass: 'key-axis',
-            ticks: axisConfig.ticks,
-            labels: {
-                maxSize: AxisModel.getLabelSize(labelConfig.maxSize.main, data[dataOptions.dataSource].map(d => d[dataOptions.keyField.name])).width,
-                position: AxisModel.getKeyAxisLabelPosition(margin, blockSize, DataManagerModel.getDataValuesByKeyField(data, dataOptions.dataSource, dataOptions.keyField.name).length),
-                visible: !TwoDimensionalModel.getChartsEmbeddedLabelsFlag(charts, orient),
-                defaultTooltip: tooltipSettings.position === 'fixed'
-            },
-            visibility: axisConfig.visibility
-        };
-    }
-    static getValueAxis(orient, axisConfig, labelConfig, margin, blockSize) {
-        return {
-            type: 'value',
-            orient: AxisModel.getAxisOrient(AxisType.Value, orient, axisConfig.position),
-            translate: {
-                translateX: AxisModel.getAxisTranslateX(AxisType.Value, orient, axisConfig.position, margin, blockSize.width),
-                translateY: AxisModel.getAxisTranslateY(AxisType.Value, orient, axisConfig.position, margin, blockSize.height)
-            },
-            cssClass: 'value-axis',
-            ticks: axisConfig.ticks,
-            labels: {
-                maxSize: labelConfig.maxSize.main,
-                position: 'straight',
-                visible: true,
-                defaultTooltip: true
-            },
-            visibility: axisConfig.visibility
-        };
-    }
-    static getAxisLength(chartOrientation, margin, blockSize) {
-        if (chartOrientation === 'horizontal') {
-            return blockSize.height - margin.top - margin.bottom;
-        }
-        else {
-            return blockSize.width - margin.left - margin.right;
-        }
-    }
-    static getAxisOrient(axisType, chartOrientation, axisPosition) {
-        if (chartOrientation === 'vertical') {
-            if (axisPosition === 'start')
-                return axisType === AxisType.Key ? 'top' : 'left';
-            return axisType === AxisType.Key ? 'bottom' : 'right';
-        }
-        if (axisPosition === 'start')
-            return axisType === AxisType.Key ? 'left' : 'top';
-        return axisType === AxisType.Key ? 'right' : 'bottom';
-    }
-    static getAxisTranslateX(axisType, chartOrientation, axisPosition, margin, blockWidth) {
-        const orient = AxisModel.getAxisOrient(axisType, chartOrientation, axisPosition);
-        if (orient === 'top' || orient === 'left')
-            return margin.left;
-        else if (orient === 'bottom')
-            return margin.left;
-        return blockWidth - margin.right;
-    }
-    static getAxisTranslateY(axisType, chartOrientation, axisPosition, margin, blockHeight) {
-        const orient = AxisModel.getAxisOrient(axisType, chartOrientation, axisPosition);
-        if (orient === 'top' || orient === 'left')
-            return margin.top;
-        else if (orient === 'bottom')
-            return blockHeight - margin.bottom;
-        return margin.top;
-    }
-    static getKeyAxisLabelPosition(margin, blockSize, scopedDataLength) {
-        const minBandSize = 50;
-        if ((blockSize.width - margin.left - margin.right) / scopedDataLength < minBandSize)
-            return 'rotated';
-        return 'straight';
-    }
-    static getLabelSize(labelMaxWidth, labelTexts) {
-        const labelSize = {
-            width: 0,
-            height: 0
-        };
-        const textBlock = document.createElement('span');
-        textBlock.style.opacity = '0';
-        textBlock.style.position = 'absolute';
-        textBlock.style.whiteSpace = 'nowrap';
-        textBlock.classList.add(CLASSES.dataLabel);
-        let maxLabel = '';
-        let biggestScore = 0;
-        let maxWidth = 0;
-        labelTexts.forEach((text) => {
-            if (ModelHelper.getStringScore(text) > biggestScore) {
-                maxLabel = text;
-                biggestScore = ModelHelper.getStringScore(text);
-            }
-        });
-        textBlock.textContent = maxLabel === '0000' ? maxLabel : maxLabel + 'D';
-        document.body.append(textBlock);
-        maxWidth = Math.ceil(textBlock.getBoundingClientRect().width);
-        labelSize.height = textBlock.getBoundingClientRect().height;
-        labelSize.width = maxWidth > labelMaxWidth ? labelMaxWidth : maxWidth;
-        textBlock.remove();
-        return labelSize;
-    }
-}

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

@@ -1,7 +0,0 @@
-import { LegendPosition } from "../../model";
-export declare type LegendItemsDirection = 'row' | 'column';
-export declare class LegendCanvasModel {
-    static getLegendHeight(texts: string[], blockWidth: number, marginLeft: number, marginRight: number, itemsPosition: LegendItemsDirection, legendPosition: LegendPosition): number;
-    static getLegendItemWidth(text: string): number;
-    static findElementsAmountByLegendSize(texts: string[], position: LegendPosition, legendBlockWidth: number, legendBlockHeight: number): number;
-}

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

@@ -1,86 +0,0 @@
-import { CLASSES } from "../../modelBuilder";
-import { LegendModel } from "./legendModel";
-export class LegendCanvasModel {
-    static getLegendHeight(texts, blockWidth, marginLeft, marginRight, itemsPosition, legendPosition) {
-        const legendWrapper = document.createElement('div');
-        legendWrapper.style.opacity = '0';
-        legendWrapper.style.display = 'flex';
-        if (itemsPosition === 'column')
-            legendWrapper.style.flexDirection = 'column';
-        legendWrapper.style.position = 'absolute';
-        legendWrapper.style.width = blockWidth - marginLeft - marginRight + 'px';
-        texts.forEach(text => {
-            const itemWrapper = document.createElement('div');
-            const colorBlock = document.createElement('span');
-            const textBlock = document.createElement('span');
-            itemWrapper.classList.add(LegendModel.getLegendItemClass(itemsPosition));
-            if (itemsPosition === 'column') {
-                itemWrapper.style.whiteSpace = 'nowrap';
-                itemWrapper.classList.add(LegendModel.getMarginClass(legendPosition));
-            }
-            colorBlock.classList.add(CLASSES.legendColor);
-            textBlock.classList.add(CLASSES.legendLabel);
-            textBlock.textContent = text;
-            itemWrapper.append(colorBlock, textBlock);
-            legendWrapper.append(itemWrapper);
-        });
-        document.body.append(legendWrapper);
-        const height = legendWrapper.offsetHeight;
-        legendWrapper.remove();
-        return height;
-    }
-    static getLegendItemWidth(text) {
-        const itemWrapper = document.createElement('div');
-        itemWrapper.style.opacity = '0';
-        const colorBlock = document.createElement('span');
-        const textBlock = document.createElement('span');
-        itemWrapper.style.display = 'inline-block';
-        itemWrapper.classList.add(CLASSES.legendItem);
-        colorBlock.classList.add(CLASSES.legendColor);
-        textBlock.classList.add(CLASSES.legendLabel);
-        textBlock.textContent = text;
-        itemWrapper.append(colorBlock, textBlock);
-        document.body.append(itemWrapper);
-        const sumWidth = itemWrapper.getBoundingClientRect().width
-            + parseFloat(window.getComputedStyle(itemWrapper, null).getPropertyValue('margin-left'))
-            + parseFloat(window.getComputedStyle(itemWrapper, null).getPropertyValue('margin-right'));
-        itemWrapper.remove();
-        return sumWidth;
-    }
-    static findElementsAmountByLegendSize(texts, position, legendBlockWidth, legendBlockHeight) {
-        const legendWrapper = document.createElement('div');
-        legendWrapper.style.opacity = '0';
-        legendWrapper.style.display = 'flex';
-        legendWrapper.style.flexDirection = 'column';
-        legendWrapper.style.position = 'absolute';
-        legendWrapper.style.width = legendBlockWidth + 'px';
-        document.body.append(legendWrapper);
-        let amount = 0;
-        for (let i = 0; i < texts.length; i++) {
-            const itemWrapper = document.createElement('div');
-            const colorBlock = document.createElement('span');
-            const textBlock = document.createElement('span');
-            itemWrapper.classList.add('legend-item-row');
-            if (position === 'bottom')
-                textBlock.classList.add('legend-label-nowrap', 'mt-10');
-            else
-                itemWrapper.classList.add('mt-15');
-            colorBlock.classList.add(CLASSES.legendColor);
-            textBlock.classList.add(CLASSES.legendLabel);
-            textBlock.textContent = texts[i];
-            itemWrapper.append(colorBlock, textBlock);
-            legendWrapper.append(itemWrapper);
-            if (legendWrapper.offsetHeight > legendBlockHeight) {
-                itemWrapper.remove();
-                if (legendBlockHeight - legendWrapper.offsetHeight >= 15 && position !== 'bottom')
-                    amount = i;
-                else
-                    amount = i - 1;
-                break;
-            }
-            amount++;
-        }
-        legendWrapper.remove();
-        return amount < 0 ? 0 : amount;
-    }
-}

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

@@ -1,13 +0,0 @@
-import { ChartNotation, Size } from "../../../config/config";
-import { BlockMargin, ILegendModel, LegendBlockModel, LegendPosition, Orient } from "../../model";
-import { LegendItemsDirection } from "./legendCanvasModel";
-/** If donut block has width less than this const, legend change postion from "right" to "bottom" */
-export declare const MIN_DONUT_BLOCK_SIZE = 260;
-export declare class LegendModel {
-    static getLegendSize(chartNotation: ChartNotation, position: Orient, texts: string[], legendMaxWidth: number, blockSize: Size, legendBlockModel: LegendBlockModel): number;
-    static getBaseLegendBlockModel(notation: ChartNotation): LegendBlockModel;
-    static getLegendModel(chartNotation: ChartNotation, legendShow: boolean, blockSize: Size, margin: BlockMargin): ILegendModel;
-    static getLegendItemClass(itemsPosition: LegendItemsDirection): string;
-    static getMarginClass(legendPosition: LegendPosition): string;
-    private static getLegendWidth;
-}

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

@@ -1,78 +0,0 @@
-import { ModelHelper } from "../../modelHelper";
-import { TitleModel } from "../titleModel";
-import { LegendCanvasModel } from "./legendCanvasModel";
-/** If donut block has width less than this const, legend change postion from "right" to "bottom" */
-export const MIN_DONUT_BLOCK_SIZE = 260;
-export class LegendModel {
-    static getLegendSize(chartNotation, position, texts, legendMaxWidth, blockSize, legendBlockModel) {
-        if (position === 'left' || position === 'right')
-            return this.getLegendWidth(texts, legendMaxWidth);
-        if (chartNotation === '2d' || chartNotation === 'interval') {
-            return LegendCanvasModel.getLegendHeight(texts, blockSize.width, legendBlockModel.coordinate[position].margin.left, legendBlockModel.coordinate[position].margin.right, 'row', position);
-        }
-        else if (chartNotation === 'polar') {
-            const size = LegendCanvasModel.getLegendHeight(texts, blockSize.width, legendBlockModel.coordinate[position].margin.left, legendBlockModel.coordinate[position].margin.right, 'column', position);
-            return size;
-        }
-    }
-    static getBaseLegendBlockModel(notation) {
-        const mt = 20, mb = 20, ml = 20, mr = 20;
-        const titleModelTemplate = TitleModel.getTitleModel();
-        return {
-            coordinate: {
-                left: {
-                    size: 0,
-                    margin: { top: mt, bottom: mb, left: ml, right: 0 },
-                    pad: 0
-                },
-                bottom: {
-                    size: 0,
-                    margin: { top: 0, bottom: 20, left: 20, right: 20 },
-                    pad: 0
-                },
-                right: {
-                    size: 0,
-                    margin: { top: titleModelTemplate.pad + titleModelTemplate.margin.top + titleModelTemplate.size, bottom: mb, left: 0, right: mr },
-                    pad: 0
-                },
-                top: {
-                    size: 0,
-                    margin: { top: 20, bottom: 0, left: 20, right: 20 },
-                    pad: titleModelTemplate.pad + titleModelTemplate.margin.top + titleModelTemplate.size
-                }
-            },
-            standartTooltip: notation === 'polar' ? false : true
-        };
-    }
-    static getLegendModel(chartNotation, legendShow, blockSize, margin) {
-        let legendPosition = 'off';
-        if (legendShow) {
-            if (chartNotation === '2d' || chartNotation === 'interval')
-                legendPosition = 'top';
-            else if (chartNotation === 'polar') {
-                legendPosition = blockSize.width - margin.left - margin.right < MIN_DONUT_BLOCK_SIZE ? 'bottom' : 'right';
-            }
-        }
-        return {
-            position: legendPosition
-        };
-    }
-    static getLegendItemClass(itemsPosition) {
-        return itemsPosition === 'column' ? 'legend-item-row' : 'legend-item-inline';
-    }
-    static getMarginClass(legendPosition) {
-        return legendPosition === 'right' ? 'mt-15' : 'mt-10';
-    }
-    static getLegendWidth(texts, legendMaxWidth) {
-        let longestText = '';
-        let biggestScore = 0;
-        texts.forEach(text => {
-            if (ModelHelper.getStringScore(text) > biggestScore) {
-                longestText = text;
-                biggestScore = ModelHelper.getStringScore(text);
-            }
-        });
-        const maxWidth = LegendCanvasModel.getLegendItemWidth(longestText + '?'); // One letter reserve
-        return maxWidth > legendMaxWidth ? legendMaxWidth : maxWidth;
-    }
-}

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

@@ -1,6 +0,0 @@
-import { OtherComponents } from "../model";
-import { ElementsOptions } from "../../designer/designerConfig";
-import { ChartNotation } from "../../config/config";
-export declare class OtherComponentsModel {
-    static getOtherComponentsModel(elementsOptions: ElementsOptions, notation: ChartNotation): OtherComponents;
-}

package/lib/model/featuresModel/otherComponents.js

@@ -1,12 +0,0 @@
-import { LegendModel } from "./legendModel/legendModel";
-import { TitleModel } from "./titleModel";
-import { TooltipModel } from "./tooltipModel";
-export class OtherComponentsModel {
-    static getOtherComponentsModel(elementsOptions, notation) {
-        return {
-            legendBlock: LegendModel.getBaseLegendBlockModel(notation),
-            titleBlock: TitleModel.getTitleModel(),
-            tooltipBlock: TooltipModel.getTooltipModel(elementsOptions.tooltip)
-        };
-    }
-}

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

@@ -1,17 +0,0 @@
-import { BlockMargin, ScaleKeyModel, ScaleKeyType, ScaleValueModel, ScaleValueType } from "../model";
-import { AxisPosition, NumberDomain, IntervalChart, TwoDimensionalChart, TwoDimensionalOptions, Size, ChartOrientation, MdtChartsDataSource } from "../../config/config";
-export declare enum ScaleType {
-    Key = 0,
-    Value = 1
-}
-export declare class ScaleModel {
-    static getScaleKey(allowableKeys: string[], orient: ChartOrientation, margin: BlockMargin, blockSize: Size, charts: TwoDimensionalChart[], barCharts: TwoDimensionalChart[]): ScaleKeyModel;
-    static getScaleLinear(options: TwoDimensionalOptions, data: MdtChartsDataSource, margin: BlockMargin, blockSize: Size): ScaleValueModel;
-    static getRangePeek(scaleType: ScaleType, chartOrientation: string, margin: BlockMargin, blockSize: Size): number;
-    static getDateValueDomain(data: MdtChartsDataSource, chart: IntervalChart, keyAxisPosition: AxisPosition, dataSource: string): [Date, Date];
-    static getLinearDomain(configDomain: NumberDomain, data: MdtChartsDataSource, configOptions: TwoDimensionalOptions): [number, number];
-    static getScaleKeyType(charts: TwoDimensionalChart[]): ScaleKeyType;
-    static getScaleValueType(charts: TwoDimensionalChart[] | IntervalChart[]): ScaleValueType;
-    static getElementsAmount(barCharts: TwoDimensionalChart[]): number;
-    static getScaleMaxValue(charts: TwoDimensionalChart[], dataSource: string, data: MdtChartsDataSource): number;
-}

package/lib/model/featuresModel/scaleModel.js

@@ -1,100 +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, margin, blockSize, charts, barCharts) {
-        return {
-            domain: allowableKeys,
-            range: {
-                start: 0,
-                end: ScaleModel.getRangePeek(ScaleType.Key, orient, margin, blockSize)
-            },
-            type: ScaleModel.getScaleKeyType(charts),
-            elementsAmount: this.getElementsAmount(barCharts)
-        };
-    }
-    static getScaleLinear(options, data, margin, blockSize) {
-        return {
-            domain: ScaleModel.getLinearDomain(options.axis.value.domain, data, options),
-            range: {
-                start: 0,
-                end: ScaleModel.getRangePeek(ScaleType.Value, options.orientation, margin, blockSize)
-            },
-            type: ScaleModel.getScaleValueType(options.charts)
-        };
-    }
-    static getRangePeek(scaleType, chartOrientation, margin, blockSize) {
-        if (chartOrientation === 'vertical')
-            return scaleType === ScaleType.Key
-                ? blockSize.width - margin.left - margin.right
-                : blockSize.height - margin.top - margin.bottom;
-        return scaleType === ScaleType.Key
-            ? blockSize.height - margin.top - margin.bottom
-            : blockSize.width - margin.left - margin.right;
-    }
-    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 = 0;
-        else
-            domainPeekMin = configDomain.start;
-        if (configDomain.end === -1)
-            domainPeekMax = this.getScaleMaxValue(configOptions.charts, configOptions.data.dataSource, data);
-        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, dataSource, data) {
-        let max = 0;
-        charts.forEach(chart => {
-            data[dataSource].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;
-    }
-}

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

@@ -1,4 +0,0 @@
-import { TitleBlockModel } from "../model";
-export declare class TitleModel {
-    static getTitleModel(): TitleBlockModel;
-}

package/lib/model/featuresModel/titleModel.js

@@ -1,14 +0,0 @@
-export class TitleModel {
-    static getTitleModel() {
-        return {
-            margin: {
-                bottom: 0,
-                left: 20,
-                right: 20,
-                top: 20
-            },
-            size: 20,
-            pad: 0
-        };
-    }
-}

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

@@ -1,4 +0,0 @@
-import { TooltipSettings } from "../../designer/designerConfig";
-export declare class TooltipModel {
-    static getTooltipModel(options: TooltipSettings): TooltipSettings;
-}

package/lib/model/featuresModel/tooltipModel.js

@@ -1,7 +0,0 @@
-export class TooltipModel {
-    static getTooltipModel(options) {
-        return {
-            position: (options === null || options === void 0 ? void 0 : options.position) || 'followCursor'
-        };
-    }
-}

package/lib/model/marginModel.d.ts

@@ -1,19 +0,0 @@
-import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
-import { DesignerConfig } from "../designer/designerConfig";
-import { BlockMargin, DataScope, LegendBlockModel, OtherComponents, PolarOptionsModel } from "./model";
-import { Size } from "../config/config";
-export declare const AXIS_HORIZONTAL_LABEL_PADDING = 15;
-export declare const AXIS_VERTICAL_LABEL_PADDING = 10;
-export declare class MarginModel {
-    static getMargin(designerConfig: DesignerConfig, config: MdtChartsConfig, otherComponents: OtherComponents, data: MdtChartsDataSource): BlockMargin;
-    static recalcPolarMarginWithScopedData(margin: BlockMargin, blockSize: Size, designerConfig: DesignerConfig, config: MdtChartsConfig, legendBlockModel: LegendBlockModel, dataScope: DataScope, options: PolarOptionsModel): void;
-    static recalcMarginByVerticalAxisLabel(margin: BlockMargin, config: MdtChartsConfig, designerConfig: DesignerConfig, dataScope: DataScope): void;
-    private static getHorizontalMarginByAxisLabels;
-    private static recalcVerticalMarginByAxisLabelHeight;
-    private static recalcHorizontalMarginByAxisLabelWidth;
-    private static recalcMarginWithLegend;
-    private static getLegendItemsContent;
-    private static appendToGlobalMarginValuesLegendMargin;
-    private static clearMarginByLegendBlockPosition;
-    private static recalcMarginByTitle;
-}