mdt-charts 1.9.11 → 1.10.3

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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,100 @@
+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

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

package/lib/model/featuresModel/titleModel.js

@@ -0,0 +1,14 @@
+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

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

package/lib/model/featuresModel/tooltipModel.js

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

package/lib/model/marginModel.d.ts

@@ -0,0 +1,19 @@
+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;
+}

package/lib/model/marginModel.js

@@ -0,0 +1,126 @@
+import { AxisModel } from "./featuresModel/axisModel";
+import { DataManagerModel } from "./dataManagerModel";
+import { LegendModel, MIN_DONUT_BLOCK_SIZE } from "./featuresModel/legendModel/legendModel";
+import { AxisType } from "./modelBuilder";
+import { TwoDimensionalModel } from "./notations/twoDimensionalModel";
+export const AXIS_HORIZONTAL_LABEL_PADDING = 15;
+export const AXIS_VERTICAL_LABEL_PADDING = 10;
+export class MarginModel {
+    static getMargin(designerConfig, config, otherComponents, data) {
+        const margin = Object.assign({}, designerConfig.canvas.chartBlockMargin);
+        this.recalcMarginWithLegend(margin, config, designerConfig.canvas.legendBlock.maxWidth, otherComponents.legendBlock, data);
+        this.recalcMarginByTitle(margin, 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, margin, 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, margin, config.options.orientation, config.options.axis, showingFlag);
+        }
+        return margin;
+    }
+    static recalcPolarMarginWithScopedData(margin, blockSize, designerConfig, config, legendBlockModel, dataScope, options) {
+        let position = LegendModel.getLegendModel(config.options.type, config.options.legend.show, config.canvas.size, margin).position;
+        if (position !== 'off') {
+            if (position === 'right' && blockSize.width - margin.left - margin.right < MIN_DONUT_BLOCK_SIZE)
+                position = 'bottom';
+            this.clearMarginByLegendBlockPosition(margin, legendBlockModel);
+            let allowableKeys = [...dataScope.allowableKeys];
+            if (dataScope.hidedRecordsAmount !== 0 && position === 'bottom')
+                allowableKeys.push('1'); // Если есть спрятанные записи, то в массив добавляется объект, чтобы выделить место в легенде для индикатора переполнения
+            const legendSize = LegendModel.getLegendSize(config.options.type, position, allowableKeys, designerConfig.canvas.legendBlock.maxWidth, config.canvas.size, legendBlockModel);
+            margin[position] += legendSize + legendBlockModel.coordinate[position].margin[position];
+            legendBlockModel.coordinate[position].size = legendSize;
+            options.legend.position = position;
+        }
+    }
+    static recalcMarginByVerticalAxisLabel(margin, 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(margin, config.canvas.size, dataScope.allowableKeys.length);
+            const marginOrient = config.options.axis.key.position === 'end' ? 'bottom' : 'top';
+            if (axisConfig === 'rotated')
+                margin[marginOrient] += (axisLabelSize.width - axisLabelSize.height);
+        }
+    }
+    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, margin, 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)
+                margin[keyAxisOrient] += labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING;
+        }
+        else if (axis.value.visibility) {
+            margin[valueAxisOrient] += labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING;
+        }
+    }
+    static recalcHorizontalMarginByAxisLabelWidth(labelSize, margin, 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) {
+            margin[keyAxisOrient] += labelSize.width + AXIS_VERTICAL_LABEL_PADDING;
+        }
+        else if ((valueAxisOrient === 'left' || valueAxisOrient === 'right') && axis.value.visibility) {
+            margin[valueAxisOrient] += labelSize.width + AXIS_VERTICAL_LABEL_PADDING;
+        }
+    }
+    static recalcMarginWithLegend(margin, config, legendMaxWidth, legendBlockModel, data) {
+        const legendPosition = LegendModel.getLegendModel(config.options.type, config.options.legend.show, config.canvas.size, margin).position;
+        if (legendPosition !== 'off') {
+            const legendItemsContent = this.getLegendItemsContent(config.options, data);
+            const legendSize = LegendModel.getLegendSize(config.options.type, legendPosition, legendItemsContent, legendMaxWidth, config.canvas.size, legendBlockModel);
+            margin[legendPosition] += legendSize;
+            if (legendSize !== 0)
+                this.appendToGlobalMarginValuesLegendMargin(margin, 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(margin, position, legendBlockModel) {
+        const legendCoordinate = legendBlockModel.coordinate;
+        if (position === 'left' || position === 'right')
+            margin[position] += legendCoordinate[position].margin.left + legendCoordinate[position].margin.right;
+        else
+            margin[position] += legendCoordinate[position].margin.top + legendCoordinate[position].margin.bottom;
+    }
+    static clearMarginByLegendBlockPosition(margin, legendBlockModel) {
+        const legendCoordinate = legendBlockModel.coordinate;
+        ['left', 'right', 'top', 'bottom'].forEach((position) => {
+            margin[position] -= legendCoordinate[position].size === 0
+                ? 0
+                : legendCoordinate[position].size + legendCoordinate[position].margin[position];
+        });
+    }
+    static recalcMarginByTitle(margin, titleBlockModel) {
+        margin.top += titleBlockModel.margin.top + titleBlockModel.size;
+    }
+}