mdt-charts 1.9.11 → 1.10.3

package/lib/model/model.d.ts

@@ -0,0 +1,221 @@
+import { ChartOrientation, MdtChartsColorField, IntervalChartType, PolarChartType, Size, TooltipOptions, TwoDimensionalChartType } from "../config/config";
+import { DataType, DonutOptionsCanvas, Formatter, TooltipSettings, Transitions } from "../designer/designerConfig";
+declare type AxisType = "key" | "value";
+export declare type Orient = "top" | "bottom" | "left" | "right";
+export declare type ScaleKeyType = "band" | "point";
+export declare type ScaleValueType = "linear" | "datetime";
+export declare type AxisLabelPosition = "straight" | "rotated";
+export declare type LegendPosition = "off" | "top" | "bottom" | "left" | "right";
+export declare type EmbeddedLabelTypeModel = "none" | "key" | "value";
+export declare type DataOptions = {
+    [option: string]: any;
+};
+export interface Model {
+    blockCanvas: BlockCanvas;
+    chartBlock: ChartBlock;
+    options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel;
+    otherComponents: OtherComponents;
+    dataSettings: DataSettings;
+    chartSettings: ChartElementsSettings;
+    transitions?: Transitions;
+}
+export interface BlockCanvas {
+    size: Size;
+    cssClass: string;
+}
+export interface ChartBlock {
+    margin: BlockMargin;
+}
+export interface BlockMargin {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+interface OptionsModel {
+    legend: ILegendModel;
+    data: OptionsModelData;
+    title: string;
+    selectable: boolean;
+    tooltip: TooltipOptions;
+}
+export interface TwoDimensionalOptionsModel extends OptionsModel {
+    type: "2d";
+    scale: IScaleModel;
+    axis: IAxisModel;
+    charts: TwoDimensionalChartModel[];
+    additionalElements: AdditionalElementsOptions;
+    orient: ChartOrientation;
+}
+export interface PolarOptionsModel extends OptionsModel {
+    type: "polar";
+    charts: PolarChartModel[];
+}
+export interface IntervalOptionsModel extends OptionsModel {
+    type: "interval";
+    scale: IScaleModel;
+    axis: IAxisModel;
+    charts: IntervalChartModel[];
+    additionalElements: AdditionalElementsOptions;
+    orient: ChartOrientation;
+}
+export interface ILegendModel {
+    position: LegendPosition;
+}
+export interface OptionsModelData {
+    dataSource: string;
+    keyField: Field;
+}
+export interface Field {
+    name: string;
+    format: DataType;
+}
+export interface IScaleModel {
+    key: ScaleKeyModel;
+    value: ScaleValueModel;
+}
+export interface ScaleKeyModel {
+    domain: any[];
+    range: RangeModel;
+    type: ScaleKeyType;
+    elementsAmount: number;
+}
+export interface ScaleValueModel {
+    domain: any[];
+    range: RangeModel;
+    type: ScaleValueType;
+}
+export interface RangeModel {
+    start: number;
+    end: number;
+}
+export interface IAxisModel {
+    key: AxisModelOptions;
+    value: AxisModelOptions;
+}
+export interface AxisModelOptions {
+    visibility: boolean;
+    type: AxisType;
+    orient: Orient;
+    translate: TranslateModel;
+    cssClass: string;
+    ticks: AxisTicksModel;
+    labels: AxisLabelModel;
+}
+export interface TranslateModel {
+    translateX: number;
+    translateY: number;
+}
+interface AxisTicksModel {
+    flag: boolean;
+}
+export interface AxisLabelModel {
+    maxSize: number;
+    position: AxisLabelPosition;
+    visible: boolean;
+    defaultTooltip: boolean;
+}
+export interface AdditionalElementsOptions {
+    gridLine: GridLineOptions;
+}
+export interface GridLineOptions {
+    flag: GridLineFlag;
+}
+export interface GridLineFlag {
+    key: boolean;
+    value: boolean;
+}
+interface ChartModel {
+    tooltip: TooltipModel;
+    cssClasses: string[];
+    style: ChartStyle;
+}
+interface TooltipModel {
+    show: boolean;
+}
+export interface ChartStyle {
+    elementColors: string[];
+    opacity: number;
+}
+export interface TwoDimensionalChartModel extends ChartModel {
+    type: TwoDimensionalChartType;
+    data: TwoDimensionalChartDataModel;
+    index: number;
+    embeddedLabels: EmbeddedLabelTypeModel;
+    isSegmented: boolean;
+    markersOptions: MarkersOptions;
+}
+export interface IntervalChartModel extends ChartModel {
+    type: IntervalChartType;
+    data: IntervalChartDataModel;
+}
+export interface PolarChartModel extends ChartModel {
+    type: PolarChartType;
+    data: PolarChartDataModel;
+}
+export interface TwoDimensionalChartDataModel {
+    valueFields: ValueField[];
+}
+export interface ValueField extends Field {
+    title: string;
+}
+export interface MarkersOptions {
+    show: boolean;
+}
+interface IntervalChartDataModel {
+    valueField1: ValueField;
+    valueField2: ValueField;
+}
+export interface PolarChartDataModel {
+    valueField: ValueField;
+    colorField?: MdtChartsColorField;
+}
+export interface DataSettings {
+    scope: DataScope;
+    format: DataFormat;
+}
+export interface DataScope {
+    hidedRecordsAmount: number;
+    allowableKeys: string[];
+}
+export interface DataFormat {
+    formatters: Formatter;
+}
+export interface ChartElementsSettings {
+    bar: BarChartSettings;
+    donut: DonutChartSettings;
+}
+export interface BarChartSettings {
+    groupMaxDistance: number;
+    groupMinDistance: number;
+    barDistance: number;
+    maxBarWidth: number;
+    minBarWidth: number;
+}
+export interface DonutChartSettings extends DonutOptionsCanvas {
+}
+export interface OtherComponents {
+    legendBlock: LegendBlockModel;
+    titleBlock: TitleBlockModel;
+    tooltipBlock: TooltipSettings;
+}
+interface ComponentBlockModel {
+    margin: BlockMargin;
+    size: number;
+    pad: number;
+}
+export interface LegendBlockModel {
+    coordinate: LegendCoordinate;
+    standartTooltip: boolean;
+}
+export interface LegendCoordinate {
+    top: LegendCanvasCoordinate;
+    bottom: LegendCanvasCoordinate;
+    left: LegendCanvasCoordinate;
+    right: LegendCanvasCoordinate;
+}
+export interface TitleBlockModel extends ComponentBlockModel {
+}
+interface LegendCanvasCoordinate extends ComponentBlockModel {
+}
+export {};

package/lib/model/model.js

@@ -0,0 +1 @@
+export {};

package/lib/model/modelBuilder.d.ts

@@ -0,0 +1,16 @@
+import { MdtChartsConfig, MdtChartsDataSource } from '../config/config';
+import { Model } from './model';
+import { DesignerConfig } from '../designer/designerConfig';
+export declare enum AxisType {
+    Key = 0,
+    Value = 1
+}
+export declare const CLASSES: {
+    dataLabel: string;
+    legendLabel: string;
+    legendColor: string;
+    legendItem: string;
+};
+export declare function assembleModel(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig): Model;
+export declare function getPreparedData(model: Model, data: MdtChartsDataSource, config: MdtChartsConfig): MdtChartsDataSource;
+export declare function getUpdatedModel(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig): Model;

package/lib/model/modelBuilder.js

@@ -0,0 +1,128 @@
+import { MarginModel } from './marginModel';
+import { TwoDimensionalModel } from './notations/twoDimensionalModel';
+import { PolarModel } from './notations/polarModel';
+import { DataManagerModel } from './dataManagerModel';
+import { IntervalModel } from './notations/intervalModel';
+import { OtherComponentsModel } from './featuresModel/otherComponents';
+import { ConfigValidator } from './configsValidator/configValidator';
+export var AxisType;
+(function (AxisType) {
+    AxisType[AxisType["Key"] = 0] = "Key";
+    AxisType[AxisType["Value"] = 1] = "Value";
+})(AxisType || (AxisType = {}));
+export const CLASSES = {
+    dataLabel: 'data-label',
+    legendLabel: 'legend-label',
+    legendColor: 'legend-circle',
+    legendItem: 'legend-item',
+};
+function getBlockCanvas(config) {
+    const size = ConfigValidator.validateCanvasSize(config.canvas.size) ? Object.assign({}, config.canvas.size) : { width: 0, height: 0 };
+    return {
+        size,
+        cssClass: config.canvas.class
+    };
+}
+function getChartBlock(margin) {
+    return {
+        margin
+    };
+}
+function getOptions(config, designerConfig, margin, dataScope, data) {
+    if (config.options.type === '2d') {
+        return TwoDimensionalModel.getOptions(config, designerConfig, margin, dataScope, data);
+    }
+    else if (config.options.type === 'polar') {
+        return PolarModel.getOptions(config, data, margin, designerConfig);
+    }
+    else if (config.options.type === 'interval') {
+        return IntervalModel.getOptions(config, designerConfig, margin, dataScope, data);
+    }
+}
+function getDataSettings(dataScope, designerConfig) {
+    return {
+        scope: dataScope,
+        format: getDataFormat(designerConfig)
+    };
+}
+function getChartSettings(barSettings, donutSettings) {
+    return {
+        bar: Object.assign({}, barSettings),
+        donut: Object.assign({}, donutSettings)
+    };
+}
+function getDataFormat(designerConfig) {
+    return {
+        formatters: designerConfig.dataFormat.formatters
+    };
+}
+function getTransitions(designerConfig) {
+    return designerConfig.transitions;
+}
+function roundMargin(margin) {
+    margin.top = Math.ceil(margin.top);
+    margin.bottom = Math.ceil(margin.bottom);
+    margin.left = Math.ceil(margin.left);
+    margin.right = Math.ceil(margin.right);
+}
+export function assembleModel(config, data, designerConfig) {
+    if (!data || Object.keys(data).length === 0)
+        return {
+            blockCanvas: getBlockCanvas(config),
+            chartBlock: null,
+            otherComponents: null,
+            options: null,
+            dataSettings: null,
+            chartSettings: null
+        };
+    resetFalsyValues(data, config.options.data.keyField.name);
+    const otherComponents = OtherComponentsModel.getOtherComponentsModel(designerConfig.elementsOptions, config.options.type);
+    const margin = MarginModel.getMargin(designerConfig, config, otherComponents, data);
+    const dataScope = DataManagerModel.getDataScope(config, margin, data, designerConfig, otherComponents.legendBlock);
+    const preparedData = DataManagerModel.getPreparedData(data, dataScope.allowableKeys, config);
+    if (config.options.type === '2d' && config.options.axis.key.visibility)
+        MarginModel.recalcMarginByVerticalAxisLabel(margin, config, designerConfig, dataScope);
+    const blockCanvas = getBlockCanvas(config);
+    const chartBlock = getChartBlock(margin);
+    const options = getOptions(config, designerConfig, margin, dataScope, preparedData);
+    const dataSettings = getDataSettings(dataScope, designerConfig);
+    const chartSettings = getChartSettings(designerConfig.canvas.chartOptions.bar, designerConfig.canvas.chartOptions.donut);
+    const transitions = getTransitions(designerConfig);
+    if (options.type === 'polar')
+        MarginModel.recalcPolarMarginWithScopedData(margin, config.canvas.size, designerConfig, config, otherComponents.legendBlock, dataScope, options);
+    roundMargin(margin);
+    return {
+        blockCanvas,
+        chartBlock,
+        otherComponents,
+        options,
+        dataSettings,
+        chartSettings,
+        transitions
+    };
+}
+function resetFalsyValues(data, keyFieldName) {
+    for (let setName in data) {
+        data[setName].forEach(dataRow => {
+            for (let fieldName in dataRow) {
+                if (fieldName === keyFieldName && !dataRow[fieldName]) {
+                    dataRow[fieldName] = '';
+                }
+                else if (dataRow[fieldName] !== 0 && !dataRow[fieldName]) {
+                    dataRow[fieldName] = 0;
+                }
+            }
+        });
+    }
+}
+export function getPreparedData(model, data, config) {
+    resetFalsyValues(data, config.options.data.keyField.name);
+    const isModelOrDataEmpty = !model || Object.keys(model).length === 0 || !data || Object.keys(data).length === 0;
+    if (isModelOrDataEmpty)
+        return null;
+    const preparedData = DataManagerModel.getPreparedData(data, model.dataSettings.scope.allowableKeys, config);
+    return preparedData;
+}
+export function getUpdatedModel(config, data, designerConfig) {
+    return assembleModel(config, data, designerConfig);
+}

package/lib/model/modelHelper.d.ts

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

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

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

@@ -0,0 +1,8 @@
+import { MdtChartsConfig, MdtChartsDataSource, IntervalOptions } from "../../config/config";
+import { DesignerConfig } from "../../designer/designerConfig";
+import { AdditionalElementsOptions, BlockMargin, DataScope, IntervalOptionsModel } from "../model";
+export declare class IntervalModel {
+    static getOptions(config: MdtChartsConfig, designerConfig: DesignerConfig, margin: BlockMargin, dataScope: DataScope, data: MdtChartsDataSource): IntervalOptionsModel;
+    static getAdditionalElements(options: IntervalOptions): AdditionalElementsOptions;
+    private static getChartsModel;
+}

package/lib/model/notations/intervalModel.js

@@ -0,0 +1,93 @@
+import { AxisModel } from "../featuresModel/axisModel";
+import { ChartStyleModel } from "../chartStyleModel";
+import { DataManagerModel } from "../dataManagerModel";
+import { LegendModel } from "../featuresModel/legendModel/legendModel";
+import { AxisType } from "../modelBuilder";
+import { ScaleModel, ScaleType } from "../featuresModel/scaleModel";
+export class IntervalModel {
+    static getOptions(config, designerConfig, margin, dataScope, data) {
+        const options = config.options;
+        return {
+            legend: LegendModel.getLegendModel(config.options.type, config.options.legend.show, config.canvas.size, margin),
+            title: options.title,
+            selectable: !!options.selectable,
+            orient: options.orientation,
+            scale: {
+                key: {
+                    domain: dataScope.allowableKeys,
+                    range: {
+                        start: 0,
+                        end: ScaleModel.getRangePeek(ScaleType.Key, options.orientation, margin, config.canvas.size)
+                    },
+                    type: 'band',
+                    elementsAmount: 1
+                },
+                value: {
+                    domain: ScaleModel.getDateValueDomain(data, options.chart, options.axis.key.position, options.data.dataSource),
+                    range: {
+                        start: 0,
+                        end: ScaleModel.getRangePeek(ScaleType.Value, options.orientation, margin, config.canvas.size)
+                    },
+                    type: 'datetime'
+                }
+            },
+            axis: {
+                key: {
+                    type: 'key',
+                    orient: AxisModel.getAxisOrient(AxisType.Key, options.orientation, options.axis.key.position),
+                    translate: {
+                        translateX: AxisModel.getAxisTranslateX(AxisType.Key, options.orientation, options.axis.key.position, margin, config.canvas.size.width),
+                        translateY: AxisModel.getAxisTranslateY(AxisType.Key, options.orientation, options.axis.key.position, margin, config.canvas.size.height)
+                    },
+                    cssClass: 'key-axis',
+                    ticks: options.axis.key.ticks,
+                    labels: {
+                        maxSize: AxisModel.getLabelSize(designerConfig.canvas.axisLabel.maxSize.main, data[options.data.dataSource].map(d => d[options.data.keyField.name])).width,
+                        position: AxisModel.getKeyAxisLabelPosition(margin, config.canvas.size, DataManagerModel.getDataValuesByKeyField(data, options.data.dataSource, options.data.keyField.name).length),
+                        visible: true,
+                        defaultTooltip: designerConfig.elementsOptions.tooltip.position === 'fixed'
+                    },
+                    visibility: options.axis.key.visibility
+                },
+                value: {
+                    type: 'value',
+                    orient: AxisModel.getAxisOrient(AxisType.Value, options.orientation, options.axis.value.position),
+                    translate: {
+                        translateX: AxisModel.getAxisTranslateX(AxisType.Value, options.orientation, options.axis.value.position, margin, config.canvas.size.width),
+                        translateY: AxisModel.getAxisTranslateY(AxisType.Value, options.orientation, options.axis.value.position, margin, config.canvas.size.height)
+                    },
+                    cssClass: 'value-axis',
+                    ticks: options.axis.value.ticks,
+                    labels: {
+                        maxSize: designerConfig.canvas.axisLabel.maxSize.main,
+                        position: 'straight',
+                        visible: true,
+                        defaultTooltip: true
+                    },
+                    visibility: options.axis.value.visibility
+                }
+            },
+            data: Object.assign({}, options.data),
+            type: options.type,
+            charts: this.getChartsModel(options.chart, designerConfig.chartStyle),
+            additionalElements: this.getAdditionalElements(options),
+            tooltip: options.tooltip
+        };
+    }
+    static getAdditionalElements(options) {
+        return {
+            gridLine: options.additionalElements.gridLine
+        };
+    }
+    static getChartsModel(chart, chartStyleConfig) {
+        const chartsModel = [];
+        chartsModel.push({
+            type: chart.type,
+            data: Object.assign({}, chart.data),
+            tooltip: chart.tooltip,
+            cssClasses: ChartStyleModel.getCssClasses(0),
+            style: ChartStyleModel.getChartStyle(1, chartStyleConfig)
+        });
+        return chartsModel;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { MdtChartsConfig, MdtChartsDataSource } from "../../config/config";
+import { DesignerConfig } from "../../designer/designerConfig";
+import { BlockMargin, PolarOptionsModel } from "../model";
+export declare class PolarModel {
+    static getOptions(config: MdtChartsConfig, data: MdtChartsDataSource, margin: BlockMargin, designerConfig: DesignerConfig): PolarOptionsModel;
+    private static getChartsModel;
+}

package/lib/model/notations/polarModel.js

@@ -0,0 +1,27 @@
+import { ChartStyleModel } from "../chartStyleModel";
+import { LegendModel } from "../featuresModel/legendModel/legendModel";
+export class PolarModel {
+    static getOptions(config, data, margin, designerConfig) {
+        const options = config.options;
+        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: LegendModel.getLegendModel(config.options.type, config.options.legend.show, config.canvas.size, margin),
+            tooltip: options.tooltip
+        };
+    }
+    static getChartsModel(chart, dataLength, chartStyleConfig) {
+        const chartsModel = [];
+        chartsModel.push({
+            type: chart.type,
+            data: Object.assign({}, chart.data),
+            tooltip: chart.tooltip,
+            cssClasses: ChartStyleModel.getCssClasses(0),
+            style: ChartStyleModel.getChartStyle(dataLength, chartStyleConfig)
+        });
+        return chartsModel;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { ChartOrientation, MdtChartsConfig, MdtChartsDataSource, TwoDimensionalChart } from "../../config/config";
+import { DesignerConfig } from "../../designer/designerConfig";
+import { BlockMargin, DataScope, TwoDimensionalOptionsModel } from "../model";
+export declare class TwoDimensionalModel {
+    static getOptions(config: MdtChartsConfig, designerConfig: DesignerConfig, margin: BlockMargin, dataScope: DataScope, data: MdtChartsDataSource): TwoDimensionalOptionsModel;
+    static getChartsEmbeddedLabelsFlag(charts: TwoDimensionalChart[], chartOrientation: ChartOrientation): boolean;
+    /**
+     * Сортирует список чартов в порядке: area - bar - line.
+     * Используется для того, чтобы при рендере графики с наибольшей площадью (area) не перекрывали графики с меньшей площадью (bar, line).
+     * @param charts Чарты из конфига
+     */
+    static sortCharts(charts: TwoDimensionalChart[]): void;
+    private static getChartsModel;
+    private static findChartsWithEmbeddedKeyLabels;
+    private static getEmbeddedLabelType;
+    private static getAdditionalElements;
+    private static getChartsByType;
+    private static getChartsValueFieldsAmount;
+}

package/lib/model/notations/twoDimensionalModel.js

@@ -0,0 +1,85 @@
+import { ChartStyleModel } from "../chartStyleModel";
+import { AxisModel } from "../featuresModel/axisModel";
+import { LegendModel } from "../featuresModel/legendModel/legendModel";
+import { ScaleModel } from "../featuresModel/scaleModel";
+export class TwoDimensionalModel {
+    static getOptions(config, designerConfig, margin, dataScope, data) {
+        const options = config.options;
+        return {
+            legend: LegendModel.getLegendModel(config.options.type, config.options.legend.show, config.canvas.size, margin),
+            title: options.title,
+            selectable: !!options.selectable,
+            orient: options.orientation,
+            scale: {
+                key: ScaleModel.getScaleKey(dataScope.allowableKeys, options.orientation, margin, config.canvas.size, options.charts, this.getChartsByType(options.charts, 'bar')),
+                value: ScaleModel.getScaleLinear(options, data, margin, config.canvas.size)
+            },
+            axis: {
+                key: AxisModel.getKeyAxis(options.charts, data, options.data, options.orientation, options.axis.key, designerConfig.canvas.axisLabel, margin, config.canvas.size, designerConfig.elementsOptions.tooltip),
+                value: AxisModel.getValueAxis(options.orientation, options.axis.value, designerConfig.canvas.axisLabel, margin, config.canvas.size)
+            },
+            type: options.type,
+            data: Object.assign({}, options.data),
+            charts: this.getChartsModel(options.charts, options.orientation, designerConfig.chartStyle),
+            additionalElements: this.getAdditionalElements(options),
+            tooltip: options.tooltip
+        };
+    }
+    static getChartsEmbeddedLabelsFlag(charts, chartOrientation) {
+        // Если НЕ найден хотя бы один чарт, который сегментированный или хотя бы один НЕ бар чарт, то лейблы можно прятать
+        return charts.findIndex(chart => chart.isSegmented || chart.type !== 'bar') === -1
+            && chartOrientation === 'horizontal'
+            && charts.length === this.findChartsWithEmbeddedKeyLabels(charts).length;
+    }
+    /**
+     * Сортирует список чартов в порядке: area - bar - line.
+     * Используется для того, чтобы при рендере графики с наибольшей площадью (area) не перекрывали графики с меньшей площадью (bar, line).
+     * @param charts Чарты из конфига
+     */
+    static sortCharts(charts) {
+        const chartOrder = ['area', 'bar', 'line'];
+        charts.sort((chart1, chart2) => chartOrder.indexOf(chart1.type) - chartOrder.indexOf(chart2.type));
+    }
+    static getChartsModel(charts, chartOrientation, chartStyleConfig) {
+        this.sortCharts(charts);
+        const chartsModel = [];
+        charts.forEach((chart, index) => {
+            chartsModel.push({
+                type: chart.type,
+                isSegmented: chart.isSegmented,
+                data: Object.assign({}, chart.data),
+                tooltip: chart.tooltip,
+                cssClasses: ChartStyleModel.getCssClasses(index),
+                style: ChartStyleModel.get2DChartStyle(charts.length, chart.type, this.getChartsValueFieldsAmount(charts), index, chart.isSegmented, chartStyleConfig),
+                embeddedLabels: this.getEmbeddedLabelType(chart, chartOrientation),
+                markersOptions: chart.markers,
+                index
+            });
+        });
+        return chartsModel;
+    }
+    static findChartsWithEmbeddedKeyLabels(charts) {
+        const chartsWithEmbeddedLabels = [];
+        charts.forEach(chart => {
+            if (chart.type === 'bar' && chart.embeddedLabels === 'key')
+                chartsWithEmbeddedLabels.push(chart);
+        });
+        return chartsWithEmbeddedLabels;
+    }
+    static getEmbeddedLabelType(currentChart, chartOrientation) {
+        if (chartOrientation === 'horizontal' && currentChart.type === 'bar')
+            return currentChart.embeddedLabels;
+        return 'none';
+    }
+    static getAdditionalElements(options) {
+        return {
+            gridLine: options.additionalElements.gridLine
+        };
+    }
+    static getChartsByType(charts, type) {
+        return charts.filter(chart => chart.type === type);
+    }
+    static getChartsValueFieldsAmount(charts) {
+        return charts.map(chart => chart.data.valueFields.length);
+    }
+}

package/lib/optionsServices/publicOptionsService.d.ts

@@ -0,0 +1,6 @@
+import { Size } from "../main";
+declare class PublicOptionsServiceClass {
+    validateSize(size: Partial<Size>): boolean;
+}
+export declare const PublicOptionsService: PublicOptionsServiceClass;
+export {};

package/lib/optionsServices/publicOptionsService.js

@@ -0,0 +1,8 @@
+import { SizeValidator } from "./validators/sizeValidator";
+class PublicOptionsServiceClass {
+    validateSize(size) {
+        const validator = new SizeValidator();
+        return validator.validate(size);
+    }
+}
+export const PublicOptionsService = new PublicOptionsServiceClass();