mdt-charts 1.29.0 → 1.30.0

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

@@ -7,26 +7,20 @@ 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,69 +2,70 @@ 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

@@ -2,11 +2,12 @@ import { Model } from "../../model/model";
 import { Engine } from "../engine";
 import { Block } from "../block/block";
 import { MdtChartsDataSource } from "../../config/config";
+import { ChartClearSelectionOptions } from "../filterManager/filterEventManager";
 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, options?: ChartClearSelectionOptions): void;
 }