mdt-charts 1.28.1 → 1.29.0

package/lib/engine/block/block.d.ts

@@ -7,20 +7,26 @@ import { Size } from "../../config/config";
 import { BlockSvg } from "./blockSvg";
 import { BlockHtml } from "./blockHtml";
 export declare class Block {
-    parentElement: HTMLElement;
-    transitionManager: TransitionManager;
-    scales: Scales;
-    filterEventManager: FilterEventManager;
-    svg: BlockSvg;
-    html: BlockHtml;
-    private wrapperCssClasses;
-    private parentElementSelection;
-    private wrapper;
-    constructor(cssClass: string, parentElement: HTMLElement, blockId: number, filterEventManager: FilterEventManager, transitions?: Transitions);
-    renderWrapper(blockSize: Size): void;
-    destroy(): void;
-    getSvg(): Selection<SVGElement, unknown, HTMLElement, any>;
-    getWrapper(): Selection<BaseType, unknown, HTMLElement, any>;
-    removeMouseEvents(): void;
-    clearWrapper(): void;
+	parentElement: HTMLElement;
+	transitionManager: TransitionManager;
+	scales: Scales;
+	filterEventManager: FilterEventManager;
+	svg: BlockSvg;
+	html: BlockHtml;
+	private wrapperCssClasses;
+	private parentElementSelection;
+	private wrapper;
+	constructor(
+		cssClass: string,
+		parentElement: HTMLElement,
+		blockId: number,
+		filterEventManager: FilterEventManager,
+		transitions?: Transitions
+	);
+	renderWrapper(blockSize: Size): void;
+	destroy(): void;
+	getSvg(): Selection<SVGElement, unknown, HTMLElement, any>;
+	getWrapper(): Selection<BaseType, unknown, HTMLElement, any>;
+	removeMouseEvents(): void;
+	clearWrapper(): void;
 }

package/lib/engine/block/block.js

@@ -7,55 +7,55 @@ import { BlockHelper } from "./blockHelper";
 import { BlockSvg } from "./blockSvg";
 import { BlockHtml } from "./blockHtml";
 export class Block {
-    constructor(cssClass, parentElement, blockId, filterEventManager, transitions = null) {
-        this.svg = new BlockSvg({
-            svgCssClasses: cssClass,
-            parentBlockId: blockId
-        });
-        this.html = new BlockHtml({ blockCssClass: cssClass });
-        this.wrapperCssClasses = Helper.getCssClassesArray(cssClass);
-        this.wrapperCssClasses = BlockHelper.getFormattedCssClassesForWrapper(this.wrapperCssClasses);
-        this.parentElement = parentElement;
-        this.parentElementSelection = select(parentElement);
-        this.transitionManager = new TransitionManager(this, transitions);
-        this.filterEventManager = filterEventManager;
-    }
-    renderWrapper(blockSize) {
-        this.wrapper = this.parentElementSelection
-            .append("div")
-            .attr("class", this.wrapperCssClasses.join(" "))
-            .style("width", blockSize.width + "px")
-            .style("height", blockSize.height + "px")
-            .style("position", "relative");
-        this.svg.initParent(this.wrapper);
-        this.html.initParent(this.wrapper);
-    }
-    destroy() {
-        this.transitionManager.interruptTransitions();
-        this.removeMouseEvents();
-        this.getWrapper().remove();
-    }
-    getSvg() {
-        //TODO: move this method in blockSvg
-        return this.svg.getBlock();
-    }
-    getWrapper() {
-        return this.wrapper;
-    }
-    removeMouseEvents() {
-        //TODO: move this method in blockSvg
-        const tipBoxes = this.getSvg().selectAll(`.${TipBox.tipBoxClass}`);
-        tipBoxes.on("mousemove", null);
-        tipBoxes.on("mouseover", null);
-        tipBoxes.on("mouseleave", null);
-        tipBoxes.on("click", null);
-        const arcItems = Donut.getAllArcGroups(this);
-        arcItems.on("mouseover", null);
-        arcItems.on("mouseleave", null);
-        arcItems.on("mousemove", null);
-        arcItems.on("click", null);
-    }
-    clearWrapper() {
-        this.getWrapper().selectAll("*").remove();
-    }
+	constructor(cssClass, parentElement, blockId, filterEventManager, transitions = null) {
+		this.svg = new BlockSvg({
+			svgCssClasses: cssClass,
+			parentBlockId: blockId
+		});
+		this.html = new BlockHtml({ blockCssClass: cssClass });
+		this.wrapperCssClasses = Helper.getCssClassesArray(cssClass);
+		this.wrapperCssClasses = BlockHelper.getFormattedCssClassesForWrapper(this.wrapperCssClasses);
+		this.parentElement = parentElement;
+		this.parentElementSelection = select(parentElement);
+		this.transitionManager = new TransitionManager(this, transitions);
+		this.filterEventManager = filterEventManager;
+	}
+	renderWrapper(blockSize) {
+		this.wrapper = this.parentElementSelection
+			.append("div")
+			.attr("class", this.wrapperCssClasses.join(" "))
+			.style("width", blockSize.width + "px")
+			.style("height", blockSize.height + "px")
+			.style("position", "relative");
+		this.svg.initParent(this.wrapper);
+		this.html.initParent(this.wrapper);
+	}
+	destroy() {
+		this.transitionManager.interruptTransitions();
+		this.removeMouseEvents();
+		this.getWrapper().remove();
+	}
+	getSvg() {
+		//TODO: move this method in blockSvg
+		return this.svg.getBlock();
+	}
+	getWrapper() {
+		return this.wrapper;
+	}
+	removeMouseEvents() {
+		//TODO: move this method in blockSvg
+		const tipBoxes = this.getSvg().selectAll(`.${TipBox.tipBoxClass}`);
+		tipBoxes.on("mousemove", null);
+		tipBoxes.on("mouseover", null);
+		tipBoxes.on("mouseleave", null);
+		tipBoxes.on("click", null);
+		const arcItems = Donut.getAllArcGroups(this);
+		arcItems.on("mouseover", null);
+		arcItems.on("mouseleave", null);
+		arcItems.on("mousemove", null);
+		arcItems.on("click", null);
+	}
+	clearWrapper() {
+		this.getWrapper().selectAll("*").remove();
+	}
 }

package/lib/engine/block/blockHelper.d.ts

@@ -1,12 +1,12 @@
 import { BlockMargin } from "../../model/model";
 import { Size } from "../../config/config";
 export interface ClipPathAttributes {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
+	x: number;
+	y: number;
+	width: number;
+	height: number;
 }
 export declare class BlockHelper {
-    static getClipPathAttributes(blockSize: Size, margin: BlockMargin): ClipPathAttributes;
-    static getFormattedCssClassesForWrapper(cssClasses: string[]): string[];
+	static getClipPathAttributes(blockSize: Size, margin: BlockMargin): ClipPathAttributes;
+	static getFormattedCssClassesForWrapper(cssClasses: string[]): string[];
 }

package/lib/engine/block/blockHelper.js

@@ -1,19 +1,19 @@
 import { Helper } from "../helpers/helper";
 export class BlockHelper {
-    static getClipPathAttributes(blockSize, margin) {
-        const outSize = 9;
-        return {
-            x: margin.left - outSize,
-            y: margin.top - outSize,
-            width: Helper.getValueOrZero(blockSize.width - margin.left - margin.right) + outSize * 2,
-            height: Helper.getValueOrZero(blockSize.height - margin.top - margin.bottom) + outSize * 2
-        };
-    }
-    static getFormattedCssClassesForWrapper(cssClasses) {
-        const wrapperClasses = [];
-        cssClasses.forEach((cssClass) => {
-            wrapperClasses.push(cssClass + "-wrapper");
-        });
-        return wrapperClasses;
-    }
+	static getClipPathAttributes(blockSize, margin) {
+		const outSize = 9;
+		return {
+			x: margin.left - outSize,
+			y: margin.top - outSize,
+			width: Helper.getValueOrZero(blockSize.width - margin.left - margin.right) + outSize * 2,
+			height: Helper.getValueOrZero(blockSize.height - margin.top - margin.bottom) + outSize * 2
+		};
+	}
+	static getFormattedCssClassesForWrapper(cssClasses) {
+		const wrapperClasses = [];
+		cssClasses.forEach((cssClass) => {
+			wrapperClasses.push(cssClass + "-wrapper");
+		});
+		return wrapperClasses;
+	}
 }

package/lib/engine/block/blockHtml.d.ts

@@ -1,14 +1,14 @@
 import { Selection } from "d3-selection";
 interface BlockHtmlOptions {
-    blockCssClass: string;
+	blockCssClass: string;
 }
 export declare class BlockHtml {
-    private parent;
-    private block;
-    private blockCssClass;
-    constructor(options: BlockHtmlOptions);
-    initParent(parent: Selection<HTMLDivElement, unknown, HTMLElement, any>): void;
-    render(): void;
-    getBlock(): Selection<HTMLDivElement, unknown, HTMLElement, any>;
+	private parent;
+	private block;
+	private blockCssClass;
+	constructor(options: BlockHtmlOptions);
+	initParent(parent: Selection<HTMLDivElement, unknown, HTMLElement, any>): void;
+	render(): void;
+	getBlock(): Selection<HTMLDivElement, unknown, HTMLElement, any>;
 }
 export {};

package/lib/engine/block/blockHtml.js

@@ -1,18 +1,18 @@
 import { NamesHelper } from "../helpers/namesHelper";
 export class BlockHtml {
-    constructor(options) {
-        this.blockCssClass = options.blockCssClass;
-    }
-    initParent(parent) {
-        this.parent = parent;
-    }
-    render() {
-        this.block = this.parent
-            .append("div")
-            .attr("class", NamesHelper.getClassName("html-chart"))
-            .classed(this.blockCssClass, true);
-    }
-    getBlock() {
-        return this.block;
-    }
+	constructor(options) {
+		this.blockCssClass = options.blockCssClass;
+	}
+	initParent(parent) {
+		this.parent = parent;
+	}
+	render() {
+		this.block = this.parent
+			.append("div")
+			.attr("class", NamesHelper.getClassName("html-chart"))
+			.classed(this.blockCssClass, true);
+	}
+	getBlock() {
+		return this.block;
+	}
 }

package/lib/engine/block/blockSvg.d.ts

@@ -2,27 +2,27 @@ import { Selection, BaseType } from "d3-selection";
 import { Size } from "../../config/config";
 import { BlockMargin } from "../../model/model";
 interface BlockSvgOptions {
-    parentBlockId: number;
-    svgCssClasses: string;
+	parentBlockId: number;
+	svgCssClasses: string;
 }
 export declare class BlockSvg {
-    private parentBlockId;
-    private parent;
-    private svgCssClasses;
-    private hatchPatternDef;
-    private readonly chartBlockClass;
-    private readonly chartGroupClass;
-    constructor(options: BlockSvgOptions);
-    initParent(parent: Selection<BaseType, unknown, HTMLElement, any>): void;
-    render(blockSize: Size): void;
-    getBlock(): Selection<SVGElement, unknown, HTMLElement, any>;
-    renderChartsBlock(): void;
-    getChartBlock(): Selection<SVGGElement, unknown, HTMLElement, any>;
-    getChartGroup(chartIndex: number): Selection<SVGGElement, any, BaseType, any>;
-    getClipPathId(): string;
-    renderChartClipPath(margin: BlockMargin, blockSize: Size): void;
-    updateChartClipPath(margin: BlockMargin, blockSize: Size): void;
-    renderBarHatchPattern(): void;
-    ensureDefsRendered(): Selection<SVGDefsElement, unknown, HTMLElement, unknown>;
+	private parentBlockId;
+	private parent;
+	private svgCssClasses;
+	private hatchPatternDef;
+	private readonly chartBlockClass;
+	private readonly chartGroupClass;
+	constructor(options: BlockSvgOptions);
+	initParent(parent: Selection<BaseType, unknown, HTMLElement, any>): void;
+	render(blockSize: Size): void;
+	getBlock(): Selection<SVGElement, unknown, HTMLElement, any>;
+	renderChartsBlock(): void;
+	getChartBlock(): Selection<SVGGElement, unknown, HTMLElement, any>;
+	getChartGroup(chartIndex: number): Selection<SVGGElement, any, BaseType, any>;
+	getClipPathId(): string;
+	renderChartClipPath(margin: BlockMargin, blockSize: Size): void;
+	updateChartClipPath(margin: BlockMargin, blockSize: Size): void;
+	renderBarHatchPattern(): void;
+	ensureDefsRendered(): Selection<SVGDefsElement, unknown, HTMLElement, unknown>;
 }
 export {};

package/lib/engine/block/blockSvg.js

@@ -2,70 +2,69 @@ import { NamesHelper } from "../helpers/namesHelper";
 import { BlockHelper } from "./blockHelper";
 import { HatchPatternDef } from "./defs/hatchPattern";
 export class BlockSvg {
-    constructor(options) {
-        this.hatchPatternDef = new HatchPatternDef();
-        this.chartBlockClass = "chart-block";
-        this.chartGroupClass = "chart-group";
-        this.svgCssClasses = options.svgCssClasses;
-        this.parentBlockId = options.parentBlockId;
-    }
-    initParent(parent) {
-        this.parent = parent;
-    }
-    render(blockSize) {
-        this.parent
-            .append("svg")
-            .attr("width", blockSize.width)
-            .attr("height", blockSize.height)
-            .attr("class", this.svgCssClasses + " " + NamesHelper.getClassName("svg-chart"));
-    }
-    getBlock() {
-        return this.parent.select(`svg.${NamesHelper.getClassName("svg-chart")}`);
-    }
-    renderChartsBlock() {
-        this.getBlock().append("g").attr("class", this.chartBlockClass);
-    }
-    getChartBlock() {
-        return this.getBlock().select(`.${this.chartBlockClass}`);
-    }
-    getChartGroup(chartIndex) {
-        let group = this.getChartBlock().select(`.${this.chartGroupClass}-${chartIndex}`);
-        if (group.empty()) {
-            group = this.getChartBlock().append("g").attr("class", `${this.chartGroupClass}-${chartIndex}`);
-        }
-        return group;
-    }
-    getClipPathId() {
-        return NamesHelper.getId("clip-path", this.parentBlockId);
-    }
-    renderChartClipPath(margin, blockSize) {
-        const attributes = BlockHelper.getClipPathAttributes(blockSize, margin);
-        this.ensureDefsRendered()
-            .append("clipPath")
-            .attr("id", this.getClipPathId())
-            .append("rect")
-            .attr("x", attributes.x)
-            .attr("y", attributes.y)
-            .attr("width", attributes.width)
-            .attr("height", attributes.height);
-    }
-    updateChartClipPath(margin, blockSize) {
-        const attributes = BlockHelper.getClipPathAttributes(blockSize, margin);
-        this.ensureDefsRendered()
-            .select("clipPath")
-            .select("rect")
-            .attr("x", attributes.x)
-            .attr("y", attributes.y)
-            .attr("width", attributes.width)
-            .attr("height", attributes.height);
-    }
-    renderBarHatchPattern() {
-        this.hatchPatternDef.appendToDefsBlock(this.ensureDefsRendered());
-    }
-    ensureDefsRendered() {
-        let defs = this.getBlock().select("defs");
-        if (defs.empty())
-            defs = this.getBlock().append("defs");
-        return defs;
-    }
+	constructor(options) {
+		this.hatchPatternDef = new HatchPatternDef();
+		this.chartBlockClass = "chart-block";
+		this.chartGroupClass = "chart-group";
+		this.svgCssClasses = options.svgCssClasses;
+		this.parentBlockId = options.parentBlockId;
+	}
+	initParent(parent) {
+		this.parent = parent;
+	}
+	render(blockSize) {
+		this.parent
+			.append("svg")
+			.attr("width", blockSize.width)
+			.attr("height", blockSize.height)
+			.attr("class", this.svgCssClasses + " " + NamesHelper.getClassName("svg-chart"));
+	}
+	getBlock() {
+		return this.parent.select(`svg.${NamesHelper.getClassName("svg-chart")}`);
+	}
+	renderChartsBlock() {
+		this.getBlock().append("g").attr("class", this.chartBlockClass);
+	}
+	getChartBlock() {
+		return this.getBlock().select(`.${this.chartBlockClass}`);
+	}
+	getChartGroup(chartIndex) {
+		let group = this.getChartBlock().select(`.${this.chartGroupClass}-${chartIndex}`);
+		if (group.empty()) {
+			group = this.getChartBlock().append("g").attr("class", `${this.chartGroupClass}-${chartIndex}`);
+		}
+		return group;
+	}
+	getClipPathId() {
+		return NamesHelper.getId("clip-path", this.parentBlockId);
+	}
+	renderChartClipPath(margin, blockSize) {
+		const attributes = BlockHelper.getClipPathAttributes(blockSize, margin);
+		this.ensureDefsRendered()
+			.append("clipPath")
+			.attr("id", this.getClipPathId())
+			.append("rect")
+			.attr("x", attributes.x)
+			.attr("y", attributes.y)
+			.attr("width", attributes.width)
+			.attr("height", attributes.height);
+	}
+	updateChartClipPath(margin, blockSize) {
+		const attributes = BlockHelper.getClipPathAttributes(blockSize, margin);
+		this.ensureDefsRendered()
+			.select("clipPath")
+			.select("rect")
+			.attr("x", attributes.x)
+			.attr("y", attributes.y)
+			.attr("width", attributes.width)
+			.attr("height", attributes.height);
+	}
+	renderBarHatchPattern() {
+		this.hatchPatternDef.appendToDefsBlock(this.ensureDefsRendered());
+	}
+	ensureDefsRendered() {
+		let defs = this.getBlock().select("defs");
+		if (defs.empty()) defs = this.getBlock().append("defs");
+		return defs;
+	}
 }

package/lib/engine/block/defs/LinearGradientDef.d.ts

@@ -1,6 +1,6 @@
 import { Selection } from "d3-selection";
 import { GradientDef } from "../../../model/model";
 export declare class LinearGradientDef {
-    render(defs: Selection<SVGDefsElement, unknown, HTMLElement, any>, gradients: GradientDef[]): void;
-    updateColors(defs: Selection<SVGDefsElement, unknown, HTMLElement, any>, gradients: GradientDef[]): void;
+	render(defs: Selection<SVGDefsElement, unknown, HTMLElement, any>, gradients: GradientDef[]): void;
+	updateColors(defs: Selection<SVGDefsElement, unknown, HTMLElement, any>, gradients: GradientDef[]): void;
 }

package/lib/engine/block/defs/LinearGradientDef.js

@@ -1,29 +1,29 @@
 export class LinearGradientDef {
-    render(defs, gradients) {
-        gradients.forEach((gradient) => {
-            const linearGradient = defs
-                .append("linearGradient")
-                .attr("id", gradient.id)
-                .attr("x1", gradient.position.x1)
-                .attr("y1", gradient.position.y1)
-                .attr("x2", gradient.position.x2)
-                .attr("y2", gradient.position.y2);
-            gradient.items.forEach((item) => {
-                linearGradient
-                    .append("stop")
-                    .attr("id", item.id)
-                    .attr("offset", item.offset)
-                    .attr("stop-opacity", item.opacity)
-                    .attr("stop-color", item.color);
-            });
-        });
-    }
-    updateColors(defs, gradients) {
-        gradients.forEach((gradient) => {
-            const linearGradient = defs.select(`#${gradient.id}`);
-            gradient.items.forEach((item) => {
-                linearGradient.select(`#${item.id}`).attr("stop-color", item.color);
-            });
-        });
-    }
+	render(defs, gradients) {
+		gradients.forEach((gradient) => {
+			const linearGradient = defs
+				.append("linearGradient")
+				.attr("id", gradient.id)
+				.attr("x1", gradient.position.x1)
+				.attr("y1", gradient.position.y1)
+				.attr("x2", gradient.position.x2)
+				.attr("y2", gradient.position.y2);
+			gradient.items.forEach((item) => {
+				linearGradient
+					.append("stop")
+					.attr("id", item.id)
+					.attr("offset", item.offset)
+					.attr("stop-opacity", item.opacity)
+					.attr("stop-color", item.color);
+			});
+		});
+	}
+	updateColors(defs, gradients) {
+		gradients.forEach((gradient) => {
+			const linearGradient = defs.select(`#${gradient.id}`);
+			gradient.items.forEach((item) => {
+				linearGradient.select(`#${item.id}`).attr("stop-color", item.color);
+			});
+		});
+	}
 }

package/lib/engine/block/defs/hatchPattern.d.ts

@@ -1,7 +1,7 @@
 import { Selection } from "d3-selection";
 export declare class HatchPatternDef {
-    static getMaskValue(): string;
-    private static readonly hatchMaskUrl;
-    private readonly hatchPattern;
-    appendToDefsBlock(defsSelection: Selection<SVGDefsElement, unknown, HTMLElement, unknown>): void;
+	static getMaskValue(): string;
+	private static readonly hatchMaskUrl;
+	private readonly hatchPattern;
+	appendToDefsBlock(defsSelection: Selection<SVGDefsElement, unknown, HTMLElement, unknown>): void;
 }

package/lib/engine/block/defs/hatchPattern.js

@@ -1,18 +1,18 @@
 export class HatchPatternDef {
-    constructor() {
-        this.hatchPattern = `
+	constructor() {
+		this.hatchPattern = `
     <pattern id="hatch-pattern" width="4" height="4" patternUnits="userSpaceOnUse"patternTransform="rotate(45)">
         <rect width="2" height="4" transform="translate(0,0)" fill="white"></rect>
     </pattern>
     <mask id="${HatchPatternDef.hatchMaskUrl}">
         <rect x="0" y="0" width="100%" height="100%" fill="url(#hatch-pattern)" />
     </mask>`;
-    }
-    static getMaskValue() {
-        return `url(#${this.hatchMaskUrl})`;
-    }
-    appendToDefsBlock(defsSelection) {
-        defsSelection.append("g").html(this.hatchPattern);
-    }
+	}
+	static getMaskValue() {
+		return `url(#${this.hatchMaskUrl})`;
+	}
+	appendToDefsBlock(defsSelection) {
+		defsSelection.append("g").html(this.hatchPattern);
+	}
 }
 HatchPatternDef.hatchMaskUrl = "hatch-mask";

package/lib/engine/colorReader/colorReader.d.ts

@@ -1,10 +1,10 @@
 import { MdtChartsDataRow } from "../../config/config";
 import { PolarChartModel } from "../../model/model";
 export declare class ColorReaderClass {
-    getColorForArc(row: MdtChartsDataRow, chart: PolarChartModel, arcIndex: number): any;
-    getChartColorField(chart: PolarChartModel): string;
-    isNeedReadFromData(chart: PolarChartModel): boolean;
-    private getColorFromData;
-    private getColorFromPalette;
+	getColorForArc(row: MdtChartsDataRow, chart: PolarChartModel, arcIndex: number): any;
+	getChartColorField(chart: PolarChartModel): string;
+	isNeedReadFromData(chart: PolarChartModel): boolean;
+	private getColorFromData;
+	private getColorFromPalette;
 }
 export declare const ColorReader: ColorReaderClass;

package/lib/engine/colorReader/colorReader.js

@@ -1,21 +1,21 @@
 export class ColorReaderClass {
-    getColorForArc(row, chart, arcIndex) {
-        if (chart.data.colorField) {
-            return this.getColorFromData(row, chart.data.colorField);
-        }
-        return this.getColorFromPalette(chart.style.elementColors, arcIndex);
-    }
-    getChartColorField(chart) {
-        return chart.data.colorField;
-    }
-    isNeedReadFromData(chart) {
-        return !!this.getChartColorField(chart);
-    }
-    getColorFromData(row, colorField) {
-        return row[colorField];
-    }
-    getColorFromPalette(colorPalette, arcIndex) {
-        return colorPalette[arcIndex % colorPalette.length];
-    }
+	getColorForArc(row, chart, arcIndex) {
+		if (chart.data.colorField) {
+			return this.getColorFromData(row, chart.data.colorField);
+		}
+		return this.getColorFromPalette(chart.style.elementColors, arcIndex);
+	}
+	getChartColorField(chart) {
+		return chart.data.colorField;
+	}
+	isNeedReadFromData(chart) {
+		return !!this.getChartColorField(chart);
+	}
+	getColorFromData(row, colorField) {
+		return row[colorField];
+	}
+	getColorFromPalette(colorPalette, arcIndex) {
+		return colorPalette[arcIndex % colorPalette.length];
+	}
 }
 export const ColorReader = new ColorReaderClass();

package/lib/engine/contentManager/contentManager.d.ts

@@ -3,10 +3,10 @@ import { Engine } from "../engine";
 import { Block } from "../block/block";
 import { MdtChartsDataSource } from "../../config/config";
 export declare class ContentManager {
-    private manager;
-    constructor(model: Model);
-    render(model: Model, engine: Engine): void;
-    updateData(block: Block, model: Model, newData: MdtChartsDataSource): void;
-    updateColors(engine: Engine, model: Model): void;
-    clearSelection(engine: Engine, model: Model): void;
+	private manager;
+	constructor(model: Model);
+	render(model: Model, engine: Engine): void;
+	updateData(block: Block, model: Model, newData: MdtChartsDataSource): void;
+	updateColors(engine: Engine, model: Model): void;
+	clearSelection(engine: Engine, model: Model): void;
 }