mdt-charts 1.9.7 → 1.9.11

package/lib/engine/helpers/helper.d.ts

@@ -1,30 +0,0 @@
-import { MdtChartsDataRow, MdtChartsDataSource } from "../../config/config";
-export declare class Helper {
-    static getRowsByKeys(keys: string[], keyFieldName: string, dataSet: MdtChartsDataRow[]): MdtChartsDataRow[];
-    static getKeysByIds(ids: number[], keyFieldName: string, dataSet: MdtChartsDataRow[]): string[];
-    static extractKeysFromRows(keyFieldName: string, dataSet: MdtChartsDataRow[]): string[];
-    static getRowsByIds(ids: number[], dataSet: MdtChartsDataRow[]): MdtChartsDataRow[];
-    static getCssClassesLine(cssClasses: string[]): string;
-    static getCssClassesArray(cssClass: string): string[];
-    static getCssClassesWithElementIndex(cssClasses: string[], index: number): string[];
-    static getRgbaFromRgb(rgbValue: string, opacity: number): string;
-    static getTranslateNumbers(transformValue: string): [number, number];
-    static getSumOfNumeric(numbers: number[]): number;
-    static parseFormattedToNumber(value: string, rankSpliter: string): number;
-    static calcDigitsAfterDot(value: number): number;
-    static checkDomainsEquality(oldDomain: string[], newDomain: string[]): boolean;
-    static getValueOrZero(value: number): number;
-    static getPXValueFromString(propertyValue: string): number;
-    /**
-     * Возвращает значение ключа в зависимости от того, обернуты ли данные
-     * @param row
-     * @param keyFieldName
-     * @param isSegmented
-     * @returns
-     */
-    static getKeyFieldValue(row: MdtChartsDataRow, keyFieldName: string, isSegmented: boolean): string;
-    /**
-     * Сравнивает старые и новые данные
-     */
-    static compareData(oldSource: MdtChartsDataSource, newSource: MdtChartsDataSource, sourceName: string): boolean;
-}

package/lib/engine/helpers/helper.js

@@ -1,89 +0,0 @@
-export class Helper {
-    static getRowsByKeys(keys, keyFieldName, dataSet) {
-        return dataSet.filter(row => keys.findIndex(key => key === row[keyFieldName]) !== -1);
-    }
-    static getKeysByIds(ids, keyFieldName, dataSet) {
-        return this.extractKeysFromRows(keyFieldName, this.getRowsByIds(ids, dataSet));
-    }
-    static extractKeysFromRows(keyFieldName, dataSet) {
-        return dataSet.map(row => row[keyFieldName]);
-    }
-    static getRowsByIds(ids, dataSet) {
-        return dataSet.filter(row => ids.findIndex(id => id === row.$id) !== -1);
-    }
-    static getCssClassesLine(cssClasses) {
-        return '.' + cssClasses.join('.');
-    }
-    static getCssClassesArray(cssClass) {
-        return cssClass.split(' ');
-    }
-    static getCssClassesWithElementIndex(cssClasses, index) {
-        return cssClasses.concat([`chart-element-${index}`]);
-    }
-    static getRgbaFromRgb(rgbValue, opacity) {
-        const rgbNumbers = rgbValue.substring(3, rgbValue.length - 1);
-        return `rgba${rgbNumbers}, ${opacity})`;
-    }
-    static getTranslateNumbers(transformValue) {
-        if (!transformValue)
-            return [0, 0];
-        const translateNumbers = transformValue.substring(10, transformValue.length - 1).split(', ');
-        const translateX = parseFloat(translateNumbers[0]);
-        const translateY = parseFloat(translateNumbers[1]);
-        return [translateX, translateY];
-    }
-    static getSumOfNumeric(numbers) {
-        return numbers.reduce((acc, value) => acc + value, 0);
-    }
-    static parseFormattedToNumber(value, rankSpliter) {
-        return parseFloat(value.replace(rankSpliter, '.').split(/\s/).join(''));
-    }
-    static calcDigitsAfterDot(value) {
-        const valueInString = value.toString();
-        const dotIndex = valueInString.lastIndexOf('.') === -1 ? valueInString.length : valueInString.lastIndexOf('.') + 1;
-        return valueInString.substring(dotIndex).length;
-    }
-    static checkDomainsEquality(oldDomain, newDomain) {
-        if (oldDomain.length !== newDomain.length)
-            return false;
-        let isEqual = true;
-        oldDomain.forEach((keyValue, index) => {
-            if (keyValue !== newDomain[index])
-                isEqual = false;
-        });
-        return isEqual;
-    }
-    static getValueOrZero(value) {
-        return Math.max(value, 0);
-    }
-    static getPXValueFromString(propertyValue) {
-        return parseFloat(propertyValue);
-    }
-    /**
-     * Возвращает значение ключа в зависимости от того, обернуты ли данные
-     * @param row
-     * @param keyFieldName
-     * @param isSegmented
-     * @returns
-     */
-    static getKeyFieldValue(row, keyFieldName, isSegmented) {
-        return isSegmented ? row.data[keyFieldName] : row[keyFieldName];
-    }
-    /**
-     * Сравнивает старые и новые данные
-     */
-    static compareData(oldSource, newSource, sourceName) {
-        if (!oldSource || !newSource || !sourceName || !oldSource[sourceName] || !newSource[sourceName] || oldSource[sourceName].length !== newSource[sourceName].length)
-            return false;
-        const oldData = oldSource[sourceName];
-        const newData = newSource[sourceName];
-        let isEqual = true;
-        oldData.forEach((row, i) => {
-            for (let key in row) {
-                if (row[key] !== newData[i][key] && isEqual)
-                    isEqual = false;
-            }
-        });
-        return isEqual;
-    }
-}

package/lib/engine/helpers/namesHelper.d.ts

@@ -1,5 +0,0 @@
-export declare class NamesHelper {
-    private static prefix;
-    static getClassName(classOfElem: string): string;
-    static getId(idName: string, blockId: number): string;
-}

package/lib/engine/helpers/namesHelper.js

@@ -1,9 +0,0 @@
-export class NamesHelper {
-    static getClassName(classOfElem) {
-        return this.prefix + classOfElem;
-    }
-    static getId(idName, blockId) {
-        return this.prefix + idName + '-' + blockId;
-    }
-}
-NamesHelper.prefix = 'charts-';

package/lib/engine/intervalNotation/gantt.d.ts

@@ -1,10 +0,0 @@
-import { MdtChartsDataRow } from '../../config/config';
-import { BarChartSettings, BlockMargin, IntervalChartModel, OptionsModelData, Orient } from "../../model/model";
-import { Block } from "../block/block";
-import { Scales } from "../features/scale/scale";
-export declare class Gantt {
-    private static readonly ganttItemClass;
-    static render(block: Block, data: MdtChartsDataRow[], dataOptions: OptionsModelData, scales: Scales, margin: BlockMargin, keyAxisOrient: Orient, chart: IntervalChartModel, barSettings: BarChartSettings): void;
-    private static fillItemsAttrs;
-    private static getItemsAttrsByKeyOrient;
-}

package/lib/engine/intervalNotation/gantt.js

@@ -1,62 +0,0 @@
-import { Scale } from "../features/scale/scale";
-import { DomHelper } from '../helpers/domHelper';
-export class Gantt {
-    static render(block, data, dataOptions, scales, margin, keyAxisOrient, chart, barSettings) {
-        const ganttItems = block.getChartBlock()
-            .selectAll(`.${this.ganttItemClass}`)
-            .data(data)
-            .enter()
-            .append('rect')
-            .attr('class', this.ganttItemClass)
-            .style('clip-path', `url(#${block.getClipPathId()})`);
-        const itemsAttrs = this.getItemsAttrsByKeyOrient(keyAxisOrient, scales, margin, dataOptions.keyField.name, chart.data.valueField1.name, chart.data.valueField2.name, barSettings);
-        this.fillItemsAttrs(ganttItems, itemsAttrs);
-        DomHelper.setCssClasses(ganttItems, chart.cssClasses);
-        DomHelper.setChartStyle(ganttItems, chart.style, 0, 'fill');
-    }
-    static fillItemsAttrs(ganttItems, attrs) {
-        ganttItems
-            .attr('x', d => attrs.x(d))
-            .attr('y', d => attrs.y(d))
-            .attr('width', d => attrs.width(d))
-            .attr('height', d => attrs.height(d));
-    }
-    static getItemsAttrsByKeyOrient(axisOrient, scales, margin, keyField, valueField1, valueField2, barSettings) {
-        const attrs = {
-            x: null,
-            y: null,
-            width: null,
-            height: null
-        };
-        const itemSize = Scale.getScaleBandWidth(scales.key) > barSettings.maxBarWidth
-            ? barSettings.maxBarWidth
-            : Scale.getScaleBandWidth(scales.key);
-        const sizeDiff = (Scale.getScaleBandWidth(scales.key) - itemSize) / 2;
-        if (axisOrient === 'top' || axisOrient === 'bottom') {
-            attrs.x = d => scales.key(d[keyField]) + margin.left + sizeDiff;
-            attrs.width = d => itemSize;
-        }
-        if (axisOrient === 'left' || axisOrient === 'right') {
-            attrs.y = d => scales.key(d[keyField]) + margin.top + sizeDiff;
-            attrs.height = d => itemSize;
-        }
-        if (axisOrient === 'top') {
-            attrs.y = d => scales.value(d[valueField1]) + margin.top;
-            attrs.height = d => scales.value(d[valueField2]) - scales.value(d[valueField1]);
-        }
-        else if (axisOrient === 'bottom') {
-            attrs.y = d => scales.value(d[valueField2]) + margin.top;
-            attrs.height = d => scales.value(d[valueField1]) - scales.value(d[valueField2]);
-        }
-        else if (axisOrient === 'left') {
-            attrs.x = d => scales.value(d[valueField1]) + margin.left;
-            attrs.width = d => scales.value(d[valueField2]) - scales.value(d[valueField1]);
-        }
-        else if (axisOrient === 'right') {
-            attrs.x = d => scales.value(d[valueField2]) + margin.left;
-            attrs.width = d => scales.value(d[valueField1]) - scales.value(d[valueField2]);
-        }
-        return attrs;
-    }
-}
-Gantt.ganttItemClass = 'gantt-item';

package/lib/engine/intervalNotation/intervalManager.d.ts

@@ -1,7 +0,0 @@
-import { MdtChartsDataSource } from "../../config/config";
-import { Model } from "../../model/model";
-import { Block } from "../block/block";
-export declare class IntervalManager {
-    static render(block: Block, model: Model, data: MdtChartsDataSource): void;
-    private static renderCharts;
-}

package/lib/engine/intervalNotation/intervalManager.js

@@ -1,30 +0,0 @@
-import { Axis } from "../features/axis/axis";
-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 { Title } from "../features/title/title";
-import { Tooltip } from "../features/tolltip/tooltip";
-import { Gantt } from "./gantt";
-export class IntervalManager {
-    static render(block, model, data) {
-        const options = model.options;
-        block.renderSvg(model.blockCanvas.size);
-        const scales = Scale.getScales(options.scale.key, options.scale.value, model.chartSettings.bar);
-        Axis.render(block, scales, options.scale, options.axis, model.blockCanvas.size);
-        GridLine.render(block, options.additionalElements.gridLine.flag, options.axis, model.blockCanvas.size, model.chartBlock.margin, options.scale.key);
-        this.renderCharts(block, options.charts, scales, data, options.data, model.chartBlock.margin, options.axis.key.orient, model.chartSettings);
-        Title.render(block, options.title, model.otherComponents.titleBlock, model.blockCanvas.size);
-        Legend.render(block, data, options, model);
-        Tooltip.render(block, model, data, model.otherComponents.tooltipBlock, scales);
-        if (model.dataSettings.scope.hidedRecordsAmount !== 0)
-            RecordOverflowAlert.render(block, model.dataSettings.scope.hidedRecordsAmount, 'top', options.orient);
-    }
-    static renderCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, chartSettings) {
-        block.renderChartsBlock();
-        charts.forEach(chart => {
-            if (chart.type === 'gantt')
-                Gantt.render(block, data[dataOptions.dataSource], dataOptions, scales, margin, keyAxisOrient, chart, chartSettings.bar);
-        });
-    }
-}

package/lib/engine/polarNotation/donut/DonutHelper.d.ts

@@ -1,15 +0,0 @@
-import { PieArcDatum, Arc, Pie } from "d3-shape";
-import { MdtChartsDataRow, Size } from "../../../config/config";
-import { BlockMargin, DonutChartSettings } from "../../../model/model";
-import { Translate } from "./donut";
-export declare class DonutHelper {
-    static getThickness(donutSettings: DonutChartSettings, blockSize: Size, margin: BlockMargin): number;
-    static getArcCentroid(blockSize: Size, margin: BlockMargin, dataItem: PieArcDatum<MdtChartsDataRow>, donutThickness: number): [number, number];
-    static getArcGeneratorObject(blockSize: Size, margin: BlockMargin, donutThickness: number): Arc<any, PieArcDatum<MdtChartsDataRow>>;
-    static getOuterRadius(margin: BlockMargin, blockSize: Size): number;
-    static getInnerRadius(outerRadius: number, thickness: number): number;
-    static getTranslate(margin: BlockMargin, blockSize: Size): Translate;
-    static getArcGenerator(outerRadius: number, innerRadius: number): Arc<any, PieArcDatum<MdtChartsDataRow>>;
-    static getPieGenerator(valueField: string, padAngle: number): Pie<any, MdtChartsDataRow>;
-    static mergeDataWithZeros(firstDataset: MdtChartsDataRow[], secondDataset: MdtChartsDataRow[], keyField: string): MdtChartsDataRow[];
-}

package/lib/engine/polarNotation/donut/DonutHelper.js

@@ -1,58 +0,0 @@
-import { merge } from "d3-array";
-import { arc, pie } from "d3-shape";
-export class DonutHelper {
-    static getThickness(donutSettings, blockSize, margin) {
-        if (Math.min(blockSize.width - margin.left - margin.right, blockSize.height - margin.bottom - margin.top) > 400)
-            return donutSettings.maxThickness;
-        return donutSettings.minThickness;
-    }
-    static getArcCentroid(blockSize, margin, dataItem, donutThickness) {
-        const arc = this.getArcGeneratorObject(blockSize, margin, donutThickness);
-        return arc.centroid(dataItem);
-    }
-    static getArcGeneratorObject(blockSize, margin, donutThickness) {
-        const outerRadius = this.getOuterRadius(margin, blockSize);
-        const arc = this.getArcGenerator(outerRadius, outerRadius - donutThickness);
-        return arc;
-    }
-    static getOuterRadius(margin, blockSize) {
-        return Math.min(blockSize.width - margin.left - margin.right, blockSize.height - margin.top - margin.bottom) / 2;
-    }
-    static getInnerRadius(outerRadius, thickness) {
-        return outerRadius - thickness;
-    }
-    static getTranslate(margin, blockSize) {
-        return {
-            x: (blockSize.width - margin.left - margin.right) / 2 + margin.left,
-            y: (blockSize.height - margin.top - margin.bottom) / 2 + margin.top
-        };
-    }
-    static getArcGenerator(outerRadius, innerRadius) {
-        return arc()
-            .innerRadius(innerRadius)
-            .outerRadius(outerRadius);
-    }
-    static getPieGenerator(valueField, padAngle) {
-        return pie()
-            .padAngle(padAngle)
-            .sort(null)
-            .value(d => d[valueField]);
-    }
-    static mergeDataWithZeros(firstDataset, secondDataset, keyField) {
-        const secondSet = new Set();
-        secondDataset.forEach(dataRow => {
-            secondSet.add(dataRow[keyField]);
-        });
-        const onlyNew = firstDataset
-            .filter(d => !secondSet.has(d[keyField]))
-            .map((d, index, array) => {
-            const data = {
-                keyField: array[index][keyField],
-                valueField: 0
-            };
-            return data;
-        });
-        const sortedMerge = merge([secondDataset, onlyNew]);
-        return sortedMerge;
-    }
-}

package/lib/engine/polarNotation/donut/donut.d.ts

@@ -1,32 +0,0 @@
-import { PieArcDatum } from 'd3-shape';
-import { Selection } from 'd3-selection';
-import { BlockMargin, DonutChartSettings, PolarChartModel } from "../../../model/model";
-import { Block } from "../../block/block";
-import { MdtChartsDataRow, Size } from '../../../config/config';
-export interface Translate {
-    x: number;
-    y: number;
-}
-export declare class Donut {
-    static readonly donutBlockClass = "donut-block";
-    static readonly arcPathClass = "arc-path";
-    static readonly arcItemClass = "arc";
-    static readonly arcHighlightedClass = "arc-highlighted";
-    static readonly arcClonesGroupClass = "arc-clones";
-    static readonly arcShadowsGroupClass = "arc-shadow-clones";
-    static readonly arcCloneClass = "arc-clone";
-    static readonly arcShadowClass = "arc-shadow-clone";
-    static render(block: Block, data: MdtChartsDataRow[], margin: BlockMargin, chart: PolarChartModel, blockSize: Size, settings: DonutChartSettings): void;
-    static update(block: Block, data: MdtChartsDataRow[], margin: BlockMargin, chart: PolarChartModel, blockSize: Size, donutSettings: DonutChartSettings, keyField: string): Promise<any>;
-    static updateColors(block: Block, chart: PolarChartModel): void;
-    static getAllArcGroups(block: Block): Selection<SVGGElement, PieArcDatum<MdtChartsDataRow>, SVGGElement, unknown>;
-    static getAllArcClones(block: Block): Selection<SVGGElement, PieArcDatum<MdtChartsDataRow>, SVGGElement, unknown>;
-    static getAllArcShadows(block: Block): Selection<SVGGElement, PieArcDatum<MdtChartsDataRow>, SVGGElement, unknown>;
-    private static renderNewArcItems;
-    private static setElementsColor;
-    /**
-     * Рендер группы для клонов сегментов доната внутри donut-block. Объекдиняет в себе стили для клонов
-     */
-    private static renderClonesG;
-    private static raiseClonesG;
-}

package/lib/engine/polarNotation/donut/donut.js

@@ -1,124 +0,0 @@
-import { interpolate } from 'd3-interpolate';
-import { Aggregator } from "../../features/aggregator/aggregator";
-import { DonutHelper } from './DonutHelper';
-import { DomHelper } from '../../helpers/domHelper';
-export class Donut {
-    static render(block, data, margin, chart, blockSize, settings) {
-        const outerRadius = DonutHelper.getOuterRadius(margin, blockSize);
-        const thickness = DonutHelper.getThickness(settings, blockSize, margin);
-        const innerRadius = DonutHelper.getInnerRadius(outerRadius, thickness);
-        const arcGenerator = DonutHelper.getArcGenerator(outerRadius, innerRadius);
-        const pieGenerator = DonutHelper.getPieGenerator(chart.data.valueField.name, settings.padAngle);
-        const translateAttr = DonutHelper.getTranslate(margin, blockSize);
-        const donutBlock = block.getSvg()
-            .append('g')
-            .attr('class', this.donutBlockClass)
-            .attr('x', translateAttr.x)
-            .attr('y', translateAttr.y)
-            .attr('transform', `translate(${translateAttr.x}, ${translateAttr.y})`);
-        this.renderNewArcItems(arcGenerator, pieGenerator, donutBlock, data, chart);
-        this.renderClonesG(donutBlock);
-        Aggregator.render(block, data, chart.data.valueField, innerRadius, translateAttr, thickness, settings.aggregatorPad);
-    }
-    static update(block, data, margin, chart, blockSize, donutSettings, keyField) {
-        const outerRadius = DonutHelper.getOuterRadius(margin, blockSize);
-        const thickness = DonutHelper.getThickness(donutSettings, blockSize, margin);
-        const innerRadius = DonutHelper.getInnerRadius(outerRadius, thickness);
-        const arcGenerator = DonutHelper.getArcGenerator(outerRadius, innerRadius);
-        const pieGenerator = DonutHelper.getPieGenerator(chart.data.valueField.name, donutSettings.padAngle);
-        const oldData = block.getSvg()
-            .selectAll(`.${this.donutBlockClass}`)
-            .selectAll('path')
-            .data()
-            .map(d => d.data);
-        const dataNewZeroRows = DonutHelper.mergeDataWithZeros(data, oldData, keyField);
-        const dataExtraZeroRows = DonutHelper.mergeDataWithZeros(oldData, data, keyField);
-        const donutBlock = block.getSvg().select(`.${this.donutBlockClass}`);
-        this.renderNewArcItems(arcGenerator, pieGenerator, donutBlock, dataNewZeroRows, chart);
-        this.setElementsColor(this.getAllArcGroups(block), chart.style.elementColors);
-        const path = this.getAllArcGroups(block)
-            .data(pieGenerator(dataExtraZeroRows))
-            .select('path');
-        const items = this.getAllArcGroups(block)
-            .data(pieGenerator(data));
-        return new Promise(resolve => {
-            this.raiseClonesG(block);
-            path
-                .interrupt()
-                .transition()
-                .duration(block.transitionManager.durations.chartUpdate)
-                .on('end', () => {
-                items.exit().remove();
-                resolve('updated');
-            })
-                .attrTween('d', function (d) {
-                const interpolateFunc = interpolate(this._currentData, d);
-                return t => {
-                    this._currentData = interpolateFunc(t); // _current - старые данные до обновления, задаются во время рендера
-                    return arcGenerator(this._currentData);
-                };
-            });
-        });
-    }
-    static updateColors(block, chart) {
-        this.setElementsColor(this.getAllArcGroups(block), chart.style.elementColors);
-    }
-    static getAllArcGroups(block) {
-        return block.getSvg()
-            .selectAll(`.${this.arcItemClass}`);
-    }
-    static getAllArcClones(block) {
-        return block.getSvg()
-            .selectAll(`.${Donut.arcCloneClass}`);
-    }
-    static getAllArcShadows(block) {
-        return block.getSvg()
-            .selectAll(`.${this.arcShadowClass}`);
-    }
-    static renderNewArcItems(arcGenerator, pieGenerator, donutBlock, data, chart) {
-        const items = donutBlock
-            .selectAll(`.${this.arcItemClass}`)
-            .data(pieGenerator(data))
-            .enter()
-            .append('g')
-            .attr('class', this.arcItemClass);
-        const arcs = items
-            .append('path')
-            .attr('d', arcGenerator)
-            .attr('class', this.arcPathClass)
-            .each(function (d) { this._currentData = d; }); // _currentData используется для получения текущих данных внутри функции обновления.
-        DomHelper.setCssClasses(arcs, chart.cssClasses);
-        this.setElementsColor(items, chart.style.elementColors);
-    }
-    static setElementsColor(arcItems, colorPalette) {
-        arcItems
-            .select('path')
-            .style('fill', (d, i) => colorPalette[i % colorPalette.length]);
-    }
-    /**
-     * Рендер группы для клонов сегментов доната внутри donut-block. Объекдиняет в себе стили для клонов
-     */
-    static renderClonesG(donutBlock) {
-        const clonesShadowsG = donutBlock.append('g').attr('class', this.arcShadowsGroupClass).raise();
-        const clonesG = donutBlock.append('g').attr('class', this.arcClonesGroupClass).raise();
-        // ElementHighlighter.setShadowFilter(clonesG);
-    }
-    static raiseClonesG(block) {
-        block.getSvg()
-            .select(`.${this.donutBlockClass}`)
-            .select(`.${this.arcShadowsGroupClass}`)
-            .raise();
-        block.getSvg()
-            .select(`.${this.donutBlockClass}`)
-            .select(`.${this.arcClonesGroupClass}`)
-            .raise();
-    }
-}
-Donut.donutBlockClass = 'donut-block';
-Donut.arcPathClass = 'arc-path';
-Donut.arcItemClass = 'arc';
-Donut.arcHighlightedClass = 'arc-highlighted';
-Donut.arcClonesGroupClass = 'arc-clones';
-Donut.arcShadowsGroupClass = 'arc-shadow-clones';
-Donut.arcCloneClass = 'arc-clone';
-Donut.arcShadowClass = 'arc-shadow-clone';

package/lib/engine/polarNotation/polarManager.d.ts

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

package/lib/engine/polarNotation/polarManager.js

@@ -1,55 +0,0 @@
-import { Legend } from "../features/legend/legend";
-import { RecordOverflowAlert } from "../features/recordOverflowAlert/recordOverflowAlert";
-import { Title } from "../features/title/title";
-import { ElementHighlighter } from "../elementHighlighter/elementHighlighter";
-import { Tooltip } from "../features/tolltip/tooltip";
-import { Aggregator } from "../features/aggregator/aggregator";
-import { Donut } from "./donut/donut";
-export class PolarManager {
-    static render(engine, model) {
-        const options = model.options;
-        engine.block.renderSvg(model.blockCanvas.size);
-        this.renderCharts(engine.block, options.charts, engine.data, options.data.dataSource, model.chartBlock.margin, model.blockCanvas.size, model.chartSettings.donut);
-        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);
-        engine.block.filterEventManager.setListenerPolar(model.chartBlock.margin, model.blockCanvas.size, options, model.chartSettings.donut);
-        if (model.dataSettings.scope.hidedRecordsAmount !== 0 && model.options.legend.position !== 'off')
-            RecordOverflowAlert.render(engine.block, model.dataSettings.scope.hidedRecordsAmount, model.options.legend.position);
-        engine.block.getSvg()
-            .on('click', (e) => {
-            if (e.target === engine.block.getSvg().node())
-                engine.block.filterEventManager.clearKeysForPolar(model.chartBlock.margin, model.blockCanvas.size, options, model.chartSettings.donut);
-        });
-    }
-    static update(block, model, data) {
-        block.transitionManager.interruptTransitions();
-        block.removeMouseEvents();
-        block.filterEventManager.updateData(data[model.options.data.dataSource]);
-        ElementHighlighter.removeDonutArcClones(block);
-        ElementHighlighter.removeFilter(Donut.getAllArcGroups(block));
-        ElementHighlighter.toggleActivityStyle(Donut.getAllArcGroups(block), true);
-        Tooltip.hide(block);
-        const options = model.options;
-        Donut.update(block, data[options.data.dataSource], model.chartBlock.margin, options.charts[0], model.blockCanvas.size, model.chartSettings.donut, options.data.keyField.name)
-            .then(() => {
-            Tooltip.render(block, model, data, model.otherComponents.tooltipBlock);
-            block.filterEventManager.setListenerPolar(model.chartBlock.margin, model.blockCanvas.size, options, model.chartSettings.donut);
-        });
-        Aggregator.update(block, data[options.data.dataSource], options.charts[0].data.valueField, model.chartSettings.donut.aggregatorPad);
-        Legend.update(block, data, model);
-        if (model.options.legend.position !== 'off')
-            RecordOverflowAlert.update(block, model.dataSettings.scope.hidedRecordsAmount, model.options.legend.position);
-    }
-    static updateColors(block, model) {
-        Legend.updateColors(block, model.options);
-        Donut.updateColors(block, model.options.charts[0]);
-    }
-    static renderCharts(block, charts, data, dataSource, margin, blockSize, donutSettings) {
-        charts.forEach((chart) => {
-            if (chart.type === 'donut')
-                Donut.render(block, data[dataSource], margin, chart, blockSize, donutSettings);
-        });
-    }
-}

package/lib/engine/transitionManager.d.ts

@@ -1,19 +0,0 @@
-import { Transitions } from "../designer/designerConfig";
-import { Block } from "./block/block";
-interface Durations extends Transitions {
-}
-export declare class TransitionManager {
-    /**
-     * Анимации обновления в ms.
-     */
-    durations: Durations;
-    private block;
-    /**
-     * Классы "подвижных" элементов
-     */
-    private transitionableElemClasses;
-    constructor(block: Block, transitionsDurations?: Transitions);
-    interruptTransitions(): void;
-    private setDurations;
-}
-export {};

package/lib/engine/transitionManager.js

@@ -1,64 +0,0 @@
-import { interrupt } from "d3-transition";
-import { Axis } from "./features/axis/axis";
-import { EmbeddedLabels } from "./features/embeddedLabels/embeddedLabels";
-import { MarkDot } from "./features/markDots/markDot";
-import { Tooltip } from "./features/tolltip/tooltip";
-import { Aggregator } from "./features/aggregator/aggregator";
-import { Donut } from "./polarNotation/donut/donut";
-import { Area } from "./twoDimensionalNotation/area/area";
-import { Bar } from "./twoDimensionalNotation/bar/bar";
-import { Line } from "./twoDimensionalNotation/line/line";
-export class TransitionManager {
-    constructor(block, transitionsDurations = null) {
-        /**
-         * Анимации обновления в ms.
-         */
-        this.durations = {
-            chartUpdate: 1000,
-            tooltipSlide: 75,
-            higlightedScale: 200,
-            markerHover: 50,
-            elementFadeOut: 400
-        };
-        /**
-         * Классы "подвижных" элементов
-         */
-        this.transitionableElemClasses = [
-            Tooltip.tooltipBlockClass,
-            Tooltip.tooltipLineClass,
-            Axis.axesClass,
-            Area.areaChartClass,
-            Bar.barItemClass,
-            Line.lineChartClass,
-            MarkDot.markerDotClass,
-            EmbeddedLabels.embeddedLabelClass,
-            Donut.arcPathClass,
-            Aggregator.aggregatorValueClass
-        ];
-        this.block = block;
-        if (transitionsDurations)
-            this.setDurations(transitionsDurations);
-    }
-    interruptTransitions() {
-        this.transitionableElemClasses.forEach(elemClass => {
-            const elementsSelection = this.block
-                .getSvg()
-                .selectAll(`.${elemClass}`)
-                .interrupt();
-            elementsSelection.nodes().forEach(node => interrupt(node));
-        });
-        this.block.getSvg().selectAll(`.${Axis.axesClass}`).selectAll('*').interrupt();
-    }
-    setDurations(durations) {
-        if (durations.chartUpdate !== undefined && durations.chartUpdate >= 0)
-            this.durations.chartUpdate = durations.chartUpdate;
-        if (durations.higlightedScale !== undefined && durations.higlightedScale >= 0)
-            this.durations.higlightedScale = durations.higlightedScale;
-        if (durations.elementFadeOut !== undefined && durations.elementFadeOut >= 0)
-            this.durations.elementFadeOut = durations.elementFadeOut;
-        if (durations.markerHover !== undefined && durations.markerHover >= 0)
-            this.durations.markerHover = durations.markerHover;
-        if (durations.tooltipSlide !== undefined && durations.tooltipSlide >= 0)
-            this.durations.tooltipSlide = durations.tooltipSlide;
-    }
-}

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

@@ -1,17 +0,0 @@
-import { BlockMargin, Field, Orient, TwoDimensionalChartModel } from "../../../model/model";
-import { Scales } from "../../features/scale/scale";
-import { Block } from "../../block/block";
-import { MdtChartsDataRow, Size } from '../../../config/config';
-export declare class Area {
-    static readonly areaChartClass = "area";
-    static render(block: Block, scales: Scales, data: MdtChartsDataRow[], keyField: Field, margin: BlockMargin, keyAxisOrient: Orient, chart: TwoDimensionalChartModel, blockSize: Size): void;
-    static update(block: Block, scales: Scales, newData: MdtChartsDataRow[], keyField: Field, margin: BlockMargin, chart: TwoDimensionalChartModel, keyAxisOrient: Orient, blockSize: Size): Promise<any>[];
-    static updateColors(block: Block, chart: TwoDimensionalChartModel): void;
-    private static renderGrouped;
-    private static renderSegmented;
-    private static updateGrouped;
-    private static updateSegmented;
-    private static updateGroupedPath;
-    private static updateSegmentedPath;
-    private static setSegmentColor;
-}