mdt-charts 1.9.7 → 1.9.11

package/lib/engine/twoDimensionalNotation/line/line.js

@@ -1,132 +0,0 @@
-import { stack } from 'd3-shape';
-import { select } from 'd3-selection';
-import { MarkDot } from "../../features/markDots/markDot";
-import { LineHelper } from './lineHelper';
-import { DomHelper } from '../../helpers/domHelper';
-import { Helper } from '../../helpers/helper';
-export class Line {
-    static render(block, scales, data, keyField, margin, keyAxisOrient, chart) {
-        if (chart.isSegmented)
-            this.renderSegmented(block, scales, data, keyField, margin, keyAxisOrient, chart);
-        else
-            this.renderGrouped(block, scales, data, keyField, margin, keyAxisOrient, chart);
-    }
-    static update(block, scales, newData, keyField, margin, keyAxisOrient, chart) {
-        let promises;
-        if (chart.isSegmented) {
-            promises = this.updateSegmeneted(block, scales, newData, keyField, margin, keyAxisOrient, chart);
-        }
-        else {
-            promises = this.updateGrouped(block, scales, newData, keyField, margin, keyAxisOrient, chart);
-        }
-        return promises;
-    }
-    static updateColors(block, chart) {
-        chart.data.valueFields.forEach((_vf, valueIndex) => {
-            const path = block.getChartGroup(chart.index)
-                .select(`.${this.lineChartClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${valueIndex}`);
-            DomHelper.setChartStyle(path, chart.style, valueIndex, 'stroke');
-            MarkDot.updateColors(block, chart, valueIndex);
-        });
-    }
-    static renderGrouped(block, scales, data, keyField, margin, keyAxisOrient, chart) {
-        chart.data.valueFields.forEach((valueField, valueIndex) => {
-            const lineGenerator = LineHelper.getLineGenerator(keyAxisOrient, scales, keyField.name, valueField.name, margin);
-            const path = block.getChartGroup(chart.index)
-                .append('path')
-                .attr('d', lineGenerator(data))
-                .attr('class', this.lineChartClass)
-                .style('fill', 'none')
-                .style('clip-path', `url(#${block.getClipPathId()})`)
-                .style('pointer-events', 'none');
-            DomHelper.setCssClasses(path, Helper.getCssClassesWithElementIndex(chart.cssClasses, valueIndex));
-            DomHelper.setChartStyle(path, chart.style, valueIndex, 'stroke');
-            MarkDot.render(block, data, keyAxisOrient, scales, margin, keyField.name, valueIndex, valueField.name, chart);
-        });
-    }
-    static renderSegmented(block, scales, data, keyField, margin, keyAxisOrient, chart) {
-        const stackedData = stack().keys(chart.data.valueFields.map(field => field.name))(data);
-        const lineGenerator = LineHelper.getSegmentedLineGenerator(keyAxisOrient, scales, keyField.name, margin);
-        const lines = block.getChartGroup(chart.index)
-            .selectAll(`.${this.lineChartClass}${Helper.getCssClassesLine(chart.cssClasses)}`)
-            .data(stackedData)
-            .enter()
-            .append('path')
-            .attr('d', d => lineGenerator(d))
-            .attr('class', this.lineChartClass)
-            .style('fill', 'none')
-            .style('clip-path', `url(#${block.getClipPathId()})`)
-            .style('pointer-events', 'none');
-        lines.each(function (d, i) {
-            DomHelper.setCssClasses(select(this), Helper.getCssClassesWithElementIndex(chart.cssClasses, i));
-        });
-        this.setSegmentColor(lines, chart.style.elementColors);
-        stackedData.forEach((dataset, stackIndex) => {
-            MarkDot.render(block, dataset, keyAxisOrient, scales, margin, keyField.name, stackIndex, '1', chart);
-        });
-    }
-    static updateGrouped(block, scales, newData, keyField, margin, keyAxisOrient, chart) {
-        const promises = [];
-        chart.data.valueFields.forEach((valueField, valueFieldIndex) => {
-            const lineGenerator = LineHelper.getLineGenerator(keyAxisOrient, scales, keyField.name, valueField.name, margin);
-            const lineObject = block.getChartGroup(chart.index)
-                .select(`.${this.lineChartClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${valueFieldIndex}`);
-            const prom = this.updateGroupedPath(block, lineObject, lineGenerator, newData);
-            promises.push(prom);
-            MarkDot.update(block, newData, keyAxisOrient, scales, margin, keyField.name, valueFieldIndex, valueField.name, chart);
-        });
-        return promises;
-    }
-    static updateSegmeneted(block, scales, newData, keyField, margin, keyAxisOrient, chart) {
-        const stackedData = stack().keys(chart.data.valueFields.map(field => field.name))(newData);
-        const lineGenerator = LineHelper.getSegmentedLineGenerator(keyAxisOrient, scales, keyField.name, margin);
-        const lines = block.getChartGroup(chart.index)
-            .selectAll(`path.${this.lineChartClass}${Helper.getCssClassesLine(chart.cssClasses)}`)
-            .data(stackedData);
-        const prom = this.updateSegmentedPath(block, lines, lineGenerator);
-        lines.each((dataset, index) => {
-            MarkDot.update(block, dataset, keyAxisOrient, scales, margin, keyField.name, index, '1', chart);
-        });
-        return [prom];
-    }
-    static updateGroupedPath(block, lineObject, lineGenerator, newData) {
-        return new Promise(resolve => {
-            if (lineObject.size() === 0) {
-                resolve('');
-                return;
-            }
-            let lineHandler = lineObject;
-            if (block.transitionManager.durations.chartUpdate > 0)
-                lineHandler = lineHandler.interrupt()
-                    .transition()
-                    .duration(block.transitionManager.durations.chartUpdate)
-                    .on('end', () => resolve(''));
-            lineHandler
-                .attr('d', lineGenerator(newData));
-            if (block.transitionManager.durations.chartUpdate <= 0)
-                resolve('');
-        });
-    }
-    static updateSegmentedPath(block, linesObjects, lineGenerator) {
-        return new Promise(resolve => {
-            if (linesObjects.size() === 0) {
-                resolve('');
-                return;
-            }
-            let linesHandler = linesObjects;
-            if (block.transitionManager.durations.chartUpdate > 0)
-                linesHandler = linesHandler.interrupt()
-                    .transition()
-                    .duration(block.transitionManager.durations.chartUpdate)
-                    .on('end', () => resolve(''));
-            linesHandler
-                .attr('d', d => lineGenerator(d));
-            if (block.transitionManager.durations.chartUpdate <= 0)
-                resolve('');
-        });
-    }
-    static setSegmentColor(segments, colorPalette) {
-        segments.style('stroke', (d, i) => colorPalette[i % colorPalette.length]);
-    }
-}
-Line.lineChartClass = 'line';

package/lib/engine/twoDimensionalNotation/line/lineHelper.d.ts

@@ -1,8 +0,0 @@
-import { Line as ILine } from 'd3-shape';
-import { MdtChartsDataRow } from '../../../config/config';
-import { Orient, BlockMargin } from "../../../model/model";
-import { Scales } from "../../features/scale/scale";
-export declare class LineHelper {
-    static getLineGenerator(keyAxisOrient: Orient, scales: Scales, keyFieldName: string, valueFieldName: string, margin: BlockMargin): ILine<MdtChartsDataRow>;
-    static getSegmentedLineGenerator(keyAxisOrient: Orient, scales: Scales, keyFieldName: string, margin: BlockMargin): ILine<MdtChartsDataRow>;
-}

package/lib/engine/twoDimensionalNotation/line/lineHelper.js

@@ -1,28 +0,0 @@
-import { line } from 'd3-shape';
-import { Scale } from "../../features/scale/scale";
-export class LineHelper {
-    static getLineGenerator(keyAxisOrient, scales, keyFieldName, valueFieldName, margin) {
-        if (keyAxisOrient === 'bottom' || keyAxisOrient === 'top') {
-            return line()
-                .x(d => Scale.getScaledValue(scales.key, d[keyFieldName]) + margin.left)
-                .y(d => scales.value(d[valueFieldName]) + margin.top);
-        }
-        if (keyAxisOrient === 'left' || keyAxisOrient === 'right') {
-            return line()
-                .x(d => scales.value(d[valueFieldName]) + margin.left)
-                .y(d => Scale.getScaledValue(scales.key, d[keyFieldName]) + margin.top);
-        }
-    }
-    static getSegmentedLineGenerator(keyAxisOrient, scales, keyFieldName, margin) {
-        if (keyAxisOrient === 'bottom' || keyAxisOrient === 'top') {
-            return line()
-                .x(d => Scale.getScaledValue(scales.key, d.data[keyFieldName]) + margin.left)
-                .y(d => scales.value(d[1]) + margin.top);
-        }
-        if (keyAxisOrient === 'left' || keyAxisOrient === 'right') {
-            return line()
-                .x(d => scales.value(d[1]) + margin.left)
-                .y(d => Scale.getScaledValue(scales.key, d.data[keyFieldName]) + margin.top);
-        }
-    }
-}

package/lib/engine/twoDimensionalNotation/twoDimensionalManager.d.ts

@@ -1,11 +0,0 @@
-import { MdtChartsDataSource } from "../../config/config";
-import { Model } from "../../model/model";
-import { Block } from "../block/block";
-import Engine from "../engine";
-export declare class TwoDimensionalManager {
-    static render(engine: Engine, model: Model): void;
-    static updateData(block: Block, model: Model, data: MdtChartsDataSource): void;
-    static updateColors(block: Block, model: Model): void;
-    private static renderCharts;
-    private static updateCharts;
-}

package/lib/engine/twoDimensionalNotation/twoDimensionalManager.js

@@ -1,101 +0,0 @@
-import { ElementHighlighter } from "../elementHighlighter/elementHighlighter";
-import { Axis } from "../features/axis/axis";
-import { EmbeddedLabels } from "../features/embeddedLabels/embeddedLabels";
-import { GridLine } from "../features/gridLine/gridLine";
-import { Legend } from "../features/legend/legend";
-import { RecordOverflowAlert } from "../features/recordOverflowAlert/recordOverflowAlert";
-import { Scale } from "../features/scale/scale";
-import { TipBox } from "../features/tipBox/tipBox";
-import { Title } from "../features/title/title";
-import { Tooltip } from "../features/tolltip/tooltip";
-import { Helper } from "../helpers/helper";
-import { Area } from "./area/area";
-import { Bar } from "./bar/bar";
-import { BarHelper } from "./bar/barHelper";
-import { Line } from "./line/line";
-export class TwoDimensionalManager {
-    static render(engine, model) {
-        const options = model.options;
-        const scales = Scale.getScales(options.scale.key, options.scale.value, model.chartSettings.bar);
-        engine.block.scales = scales;
-        engine.block.renderSvg(model.blockCanvas.size);
-        Axis.render(engine.block, scales, options.scale, options.axis, model.blockCanvas.size);
-        GridLine.render(engine.block, options.additionalElements.gridLine.flag, options.axis, model.blockCanvas.size, model.chartBlock.margin, options.scale.key);
-        this.renderCharts(engine.block, options.charts, scales, engine.data, options.data, model.chartBlock.margin, options.axis.key.orient, model.chartSettings.bar, model.blockCanvas.size);
-        engine.block.filterEventManager.registerEventFor2D(scales.key, model.chartBlock.margin, model.blockCanvas.size, options);
-        engine.block.filterEventManager.event2DUpdate(options);
-        Title.render(engine.block, options.title, model.otherComponents.titleBlock, model.blockCanvas.size);
-        Legend.render(engine.block, engine.data, options, model);
-        Tooltip.render(engine.block, model, engine.data, model.otherComponents.tooltipBlock, scales);
-        if (model.dataSettings.scope.hidedRecordsAmount !== 0)
-            RecordOverflowAlert.render(engine.block, model.dataSettings.scope.hidedRecordsAmount, 'top', options.orient);
-        engine.block.getSvg()
-            .on('click', (e) => {
-            if (e.target === engine.block.getSvg().node())
-                engine.block.filterEventManager.clearKeysFor2D(options);
-        });
-    }
-    static updateData(block, model, data) {
-        block.transitionManager.interruptTransitions();
-        block.filterEventManager.updateData(data[model.options.data.dataSource]);
-        TipBox.clearEvents(block);
-        Tooltip.hide(block);
-        const options = model.options;
-        ElementHighlighter.remove2DChartsFullHighlighting(block, options.charts);
-        const scales = Scale.getScales(options.scale.key, options.scale.value, model.chartSettings.bar);
-        const keyDomainEquality = Helper.checkDomainsEquality(block.scales.key.domain(), scales.key.domain());
-        block.scales = scales;
-        Axis.update(block, scales, options.scale, options.axis, model.blockCanvas.size, keyDomainEquality);
-        GridLine.update(block, options.additionalElements.gridLine.flag, options.axis, model.blockCanvas.size, model.chartBlock.margin, options.scale.key);
-        const promises = this.updateCharts(block, options.charts, scales, data, model.options.data, model.chartBlock.margin, options.axis.key.orient, model.blockCanvas.size, model.chartSettings.bar);
-        Promise.all(promises)
-            .then(() => {
-            block.filterEventManager.event2DUpdate(options);
-            block.filterEventManager.registerEventFor2D(scales.key, model.chartBlock.margin, model.blockCanvas.size, options);
-            Tooltip.render(block, model, data, model.otherComponents.tooltipBlock, scales);
-        });
-        RecordOverflowAlert.update(block, model.dataSettings.scope.hidedRecordsAmount, 'top', options.orient);
-    }
-    static updateColors(block, model) {
-        Legend.updateColors(block, model.options);
-        model.options.charts.forEach(chart => {
-            if (chart.type === 'bar')
-                Bar.updateColors(block, chart);
-            else if (chart.type === 'line')
-                Line.updateColors(block, chart);
-            else if (chart.type === 'area')
-                Area.updateColors(block, chart);
-        });
-    }
-    static renderCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, barSettings, blockSize) {
-        block.renderChartClipPath(margin, blockSize);
-        block.renderChartsBlock();
-        charts.forEach((chart) => {
-            if (chart.type === 'bar')
-                Bar.render(block, scales, data[dataOptions.dataSource], dataOptions.keyField, margin, keyAxisOrient, chart, blockSize, barSettings, BarHelper.getBarsInGroupAmount(charts), chart.isSegmented, charts.findIndex(ch => ch.type === 'bar'));
-            else if (chart.type === 'line')
-                Line.render(block, scales, data[dataOptions.dataSource], dataOptions.keyField, margin, keyAxisOrient, chart);
-            else if (chart.type === 'area')
-                Area.render(block, scales, data[dataOptions.dataSource], dataOptions.keyField, margin, keyAxisOrient, chart, blockSize);
-        });
-        EmbeddedLabels.raiseGroups(block);
-    }
-    static updateCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, blockSize, barSettings) {
-        block.updateChartClipPath(margin, blockSize);
-        let promises = [];
-        charts.forEach((chart) => {
-            let proms;
-            if (chart.type === 'bar') {
-                proms = Bar.update(block, data[dataOptions.dataSource], scales, margin, keyAxisOrient, chart, blockSize, BarHelper.getBarsInGroupAmount(charts), dataOptions.keyField, charts.findIndex(ch => ch.type === 'bar'), barSettings, chart.isSegmented);
-            }
-            else if (chart.type === 'line') {
-                proms = Line.update(block, scales, data[dataOptions.dataSource], dataOptions.keyField, margin, keyAxisOrient, chart);
-            }
-            else if (chart.type === 'area') {
-                proms = Area.update(block, scales, data[dataOptions.dataSource], dataOptions.keyField, margin, chart, keyAxisOrient, blockSize);
-            }
-            promises.push(...proms);
-        });
-        return promises;
-    }
-}

package/lib/engine/valueFormatter.d.ts

@@ -1,6 +0,0 @@
-import { Formatter } from '../designer/designerConfig';
-export declare class ValueFormatter {
-    private static format;
-    static formatField(fieldFormat: string, value: any): string;
-    static setFormatFunction(formatFunction: Formatter): void;
-}

package/lib/engine/valueFormatter.js

@@ -1,8 +0,0 @@
-export class ValueFormatter {
-    static formatField(fieldFormat, value) {
-        return this.format(value, { type: fieldFormat });
-    }
-    static setFormatFunction(formatFunction) {
-        this.format = formatFunction;
-    }
-}

package/lib/main.d.ts

@@ -1,79 +0,0 @@
-import { MdtChartsConfig, MdtChartsDataSource, NewSize, Size } from "./config/config";
-import { DesignerConfig } from "./designer/designerConfig";
-import { FilterCallback } from "./engine/filterManager/filterEventManager";
-export interface IChart {
-    /**
-     * Рендер графика
-     * @param parentElement родительский элемент для графика
-     */
-    render(parentElement: HTMLElement): void;
-    /**
-     * Удаление графика со страницы
-     */
-    destroy(): void;
-    /**
-     * Обновление графика для новых данных
-     * @param data Новые данные
-     */
-    updateData(data: MdtChartsDataSource): void;
-    /**
-     * Изменение размера блока с графиком
-     * @param newSize Новый размер
-     */
-    updateSize(newSize: Size): void;
-    /**
-     * Обновление цветов графиков на основе новых базовых цветов
-     * @param newColors Новые базовые цвета
-     */
-    updateColors(newColors: string[]): void;
-}
-export declare class Chart implements IChart {
-    static chartCounter: number;
-    private config;
-    private designerConfig;
-    private model;
-    private data;
-    private parentElement;
-    private isResizable;
-    private engine;
-    private resizeHandler;
-    /**
-     * @param config Объект конфигуратора
-     * @param designerConfig Объект конфигуратора дизайнера
-     * @param data Данные
-     * @param isResizable Флаг подстройки размера блока графика под родительский элемент
-     * @param filterCallback Функция коллбэк, вызываемая во время клика на элемент графика. Предназначена для обеспечения кросс-фильтрации
-     * @param selectedIds Id выделенных записей
-     */
-    constructor(config: MdtChartsConfig, designerConfig: DesignerConfig, data: MdtChartsDataSource, isResizable?: boolean, filterCallback?: FilterCallback, selectedIds?: number[]);
-    /**
-     * Рендер графика
-     * @param parentElement родительский элемент для графика
-     */
-    render(parentElement: HTMLElement): void;
-    /**
-     * Удаление графика со страницы
-     */
-    destroy(): void;
-    /**
-     * Обновление графика для новых данных
-     * @param data Новые данные
-     */
-    updateData(data: MdtChartsDataSource): void;
-    /**
-     * Изменение размера блока с графиком
-     * @param newSize Новый размер
-     */
-    updateSize(newSize: Partial<NewSize>): void;
-    /**
-     * Обновление цветов графиков на основе новых базовых цветов
-     * @param newColors Новые базовые цвета
-     */
-    updateColors(newColors: string[]): void;
-    private registerResizeEvent;
-    private removeResizeEvent;
-    private resizeListener;
-}
-export * from "./config/config";
-export * from "./designer/designerConfig";
-export { FilterCallback } from "./engine/filterManager/filterEventManager";

package/lib/main.js

@@ -1,85 +0,0 @@
-import Engine from "./engine/engine";
-import { assembleModel, getPreparedData } from "./model/modelBuilder";
-export class Chart {
-    /**
-     * @param config Объект конфигуратора
-     * @param designerConfig Объект конфигуратора дизайнера
-     * @param data Данные
-     * @param isResizable Флаг подстройки размера блока графика под родительский элемент
-     * @param filterCallback Функция коллбэк, вызываемая во время клика на элемент графика. Предназначена для обеспечения кросс-фильтрации
-     * @param selectedIds Id выделенных записей
-     */
-    constructor(config, designerConfig, data, isResizable = false, filterCallback = null, selectedIds = []) {
-        this.resizeHandler = this.resizeListener.bind(this);
-        Chart.chartCounter++;
-        this.config = config;
-        this.designerConfig = designerConfig;
-        this.data = data;
-        this.isResizable = isResizable;
-        this.model = assembleModel(this.config, this.data, this.designerConfig);
-        this.engine = new Engine(Chart.chartCounter, filterCallback, selectedIds);
-    }
-    /**
-     * Рендер графика
-     * @param parentElement родительский элемент для графика
-     */
-    render(parentElement) {
-        this.parentElement = parentElement;
-        this.engine.render(this.model, getPreparedData(this.model, this.data, this.config), this.parentElement);
-        if (this.isResizable)
-            this.registerResizeEvent();
-    }
-    /**
-     * Удаление графика со страницы
-     */
-    destroy() {
-        this.engine.destroy();
-        if (this.isResizable)
-            this.removeResizeEvent();
-    }
-    /**
-     * Обновление графика для новых данных
-     * @param data Новые данные
-     */
-    updateData(data) {
-        this.model = assembleModel(this.config, data, this.designerConfig);
-        this.data = data;
-        this.engine.updateData(this.model, getPreparedData(this.model, this.data, this.config));
-    }
-    /**
-     * Изменение размера блока с графиком
-     * @param newSize Новый размер
-     */
-    updateSize(newSize) {
-        if (newSize.height)
-            this.config.canvas.size.height = newSize.height;
-        if (newSize.width)
-            this.config.canvas.size.width = newSize.width;
-        this.model = assembleModel(this.config, this.data, this.designerConfig);
-        this.engine.updateFullBlock(this.model, getPreparedData(this.model, this.data, this.config));
-    }
-    /**
-     * Обновление цветов графиков на основе новых базовых цветов
-     * @param newColors Новые базовые цвета
-     */
-    updateColors(newColors) {
-        this.designerConfig.chartStyle.baseColors = [...newColors];
-        this.model = assembleModel(this.config, this.data, this.designerConfig);
-        this.engine.updateColors(this.model);
-    }
-    registerResizeEvent() {
-        window.addEventListener('resize', this.resizeHandler);
-    }
-    removeResizeEvent() {
-        window.removeEventListener('resize', this.resizeHandler);
-    }
-    resizeListener() {
-        this.updateSize({
-            height: null,
-            width: this.parentElement.offsetWidth
-        });
-    }
-}
-Chart.chartCounter = 0;
-export * from "./config/config";
-export * from "./designer/designerConfig";

package/lib/model/chartStyleModel.d.ts

@@ -1,16 +0,0 @@
-import { TwoDimensionalChartType } from "../config/config";
-import { ChartStyleConfig } from "../designer/designerConfig";
-import { ChartStyle } from "./model";
-export declare class ChartStyleModel {
-    private static safeColorsAmount;
-    private static standartColors;
-    static getCssClasses(chartIndex: number): string[];
-    static get2DChartStyle(chartsAmount: number, chartType: TwoDimensionalChartType, chartsFieldsAmounts: number[], chartIndex: number, isSegmented: boolean, styleConfig: ChartStyleConfig): ChartStyle;
-    static getChartStyle(elementsAmount: number, styleConfig: ChartStyleConfig): ChartStyle;
-    private static getChartColors;
-    private static getChartOpacity;
-    private static getColorSet;
-    private static checkAndGet;
-    private static getStartIndex;
-    private static resetColor;
-}

package/lib/model/chartStyleModel.js

@@ -1,67 +0,0 @@
-import * as chroma from "chroma-js";
-import { ModelHelper } from "./modelHelper";
-export class ChartStyleModel {
-    static getCssClasses(chartIndex) {
-        const cssClasses = [`chart-${chartIndex}`];
-        return cssClasses;
-    }
-    static get2DChartStyle(chartsAmount, chartType, chartsFieldsAmounts, chartIndex, isSegmented, styleConfig) {
-        const startIndex = this.getStartIndex(chartIndex, chartsFieldsAmounts);
-        const baseColors = this.checkAndGet(styleConfig.baseColors);
-        const palette = this.getColorSet(baseColors, ModelHelper.getSum(chartsFieldsAmounts));
-        return {
-            elementColors: this.getChartColors(palette, chartsFieldsAmounts[chartIndex], startIndex, chartType),
-            opacity: this.getChartOpacity(chartsAmount, chartType, chartsFieldsAmounts[chartIndex], isSegmented)
-        };
-    }
-    static getChartStyle(elementsAmount, styleConfig) {
-        const baseColors = this.checkAndGet(styleConfig.baseColors);
-        return {
-            elementColors: this.getColorSet(baseColors, elementsAmount),
-            opacity: 1
-        };
-    }
-    static getChartColors(palette, elementsAmount, startIndex, chartType) {
-        const selectedColors = palette.slice(startIndex, startIndex + elementsAmount);
-        if (chartType !== 'line')
-            return selectedColors;
-        for (let i = 0; i < selectedColors.length; i++) {
-            selectedColors[i] = chroma.mix(selectedColors[i], 'white', 0.2).saturate(3).hex();
-        }
-        return selectedColors;
-    }
-    static getChartOpacity(chartsLength, chartType, chartsValueFieldAmount, isSegmented) {
-        if (chartType === 'area' && (chartsLength > 1 || chartsValueFieldAmount > 1) && !isSegmented)
-            return 0.5; // combined area with other charts has 0.5 opacity
-        return 1;
-    }
-    static getColorSet(baseColors, elementsAmount) {
-        return chroma.scale(baseColors)
-            .mode('rgb')
-            .domain([0, 0.55, 0.75, 1])
-            .colors(elementsAmount <= 1 ? 2 : elementsAmount);
-    }
-    static checkAndGet(baseColors) {
-        if (baseColors.length === 0 || baseColors.filter(color => color === 'rgba(0, 0, 0, 0)' || !color).length > 0) {
-            return this.standartColors;
-        }
-        return baseColors;
-    }
-    static getStartIndex(chartIndex, chartsFieldsAmounts) {
-        let startIndex = 0;
-        for (let i = 0; i < chartIndex; i++) {
-            startIndex += chartsFieldsAmounts[i];
-        }
-        return startIndex;
-    }
-    static resetColor(index, baseColor) {
-        let color = chroma(baseColor)
-            .luminance(0.5)
-            .saturate(1.5 + Math.floor(index / this.safeColorsAmount) * 0.5);
-        color = chroma(color)
-            .set('hsv.h', chroma(color).get('hsv.h') + Math.floor(index / this.safeColorsAmount) * 4);
-        return color.hex();
-    }
-}
-ChartStyleModel.safeColorsAmount = 8;
-ChartStyleModel.standartColors = ["#209DE3", "#FF3131", "#FFBA00", "#20B078"];

package/lib/model/dataManagerModel.d.ts

@@ -1,22 +0,0 @@
-import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
-import { DesignerConfig } from "../designer/designerConfig";
-import { BlockMargin, DataScope, LegendBlockModel } from "./model";
-export declare class DataManagerModel {
-    static getPreparedData(data: MdtChartsDataSource, allowableKeys: string[], config: MdtChartsConfig): MdtChartsDataSource;
-    static getDataScope(config: MdtChartsConfig, margin: BlockMargin, data: MdtChartsDataSource, designerConfig: DesignerConfig, legendBlock: LegendBlockModel): DataScope;
-    static getDataValuesByKeyField(data: MdtChartsDataSource, dataSourceName: string, keyFieldName: string): string[];
-    private static getDataScopeFor2D;
-    private static getDataScopeForPolar;
-    /**
-     * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
-     * @param configOptions
-     * @param chartsLength
-     */
-    private static getElementsInGroupAmount;
-    private static getBarChartsInGroupAmount;
-    private static getScopedData;
-    private static getScopedChartData;
-    private static setDataType;
-    private static getTypedData;
-    private static getDataLimitByItemSize;
-}