mdt-charts 1.9.7 → 1.9.11

package/lib/model/marginModel.js

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

package/lib/model/model.d.ts

@@ -1,220 +0,0 @@
-import { ChartOrientation, 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;
-}
-interface PolarChartDataModel {
-    valueField: ValueField;
-}
-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

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

package/lib/model/modelBuilder.d.ts

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

@@ -1,128 +0,0 @@
-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';
-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) {
-    return {
-        size: {
-            width: config.canvas.size.width,
-            height: config.canvas.size.height
-        },
-        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);
-    if (!model || Object.keys(model).length === 0 || !data || Object.keys(data).length === 0)
-        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

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

package/lib/model/modelHelper.js

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

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

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

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

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