mdt-charts 1.29.0 → 1.29.1

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

@@ -5,21 +5,18 @@ import { BaseType, Selection } from "d3-selection";
 import { Segment } from "../../../engine/twoDimensionalNotation/lineLike/generatorMiddleware/lineLikeGeneratorDefineMiddleware";
 import { Line as ILine } from "d3-shape";
 interface LineBuilderOptions {
-	elementAccessors: {
-		getBlock: () => Block;
-	};
+    elementAccessors: {
+        getBlock: () => Block;
+    };
 }
 export declare class LineBuilder {
-	private readonly options;
-	private readonly chart;
-	private readonly lineGenerator;
-	constructor(options: LineBuilderOptions, chart: TwoDimensionalChartModel, lineGenerator: ILine<MdtChartsDataRow>);
-	renderSegmented(stakedData: Segment[][], lineClass: string): Selection<SVGPathElement, Segment[], SVGGElement, any>;
-	setSegmentColor(segments: Selection<SVGGElement, unknown, SVGGElement, unknown>, colorPalette: string[]): void;
-	updateSegmentedPath(linesObjects: Selection<BaseType, any, BaseType, any>): Promise<any>;
-	getAllLinesWithNewData(
-		stakedData: Segment[][],
-		lineClass: string
-	): Selection<SVGPathElement, Segment[], SVGGElement, any>;
+    private readonly options;
+    private readonly chart;
+    private readonly lineGenerator;
+    constructor(options: LineBuilderOptions, chart: TwoDimensionalChartModel, lineGenerator: ILine<MdtChartsDataRow>);
+    renderSegmented(stakedData: Segment[][], lineClass: string): Selection<SVGPathElement, Segment[], SVGGElement, any>;
+    setSegmentColor(segments: Selection<SVGGElement, unknown, SVGGElement, unknown>, colorPalette: string[]): void;
+    updateSegmentedPath(linesObjects: Selection<BaseType, any, BaseType, any>): Promise<any>;
+    getAllLinesWithNewData(stakedData: Segment[][], lineClass: string): Selection<SVGPathElement, Segment[], SVGGElement, any>;
 }
 export {};

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

@@ -1,50 +1,51 @@
 import { Helper } from "../../../engine/helpers/helper";
 export class LineBuilder {
-	constructor(options, chart, lineGenerator) {
-		this.options = options;
-		this.chart = chart;
-		this.lineGenerator = lineGenerator;
-	}
-	renderSegmented(stakedData, lineClass) {
-		const block = this.options.elementAccessors.getBlock();
-		return block.svg
-			.getChartGroup(this.chart.index)
-			.selectAll(`.${lineClass}${Helper.getCssClassesLine(this.chart.cssClasses)}`)
-			.data(stakedData)
-			.enter()
-			.append("path")
-			.attr("d", (d) => this.lineGenerator(d))
-			.attr("class", lineClass)
-			.style("fill", "none")
-			.style("clip-path", `url(#${block.svg.getClipPathId()})`)
-			.style("pointer-events", "none");
-	}
-	setSegmentColor(segments, colorPalette) {
-		segments.style("stroke", (d, i) => colorPalette[i % colorPalette.length]);
-	}
-	updateSegmentedPath(linesObjects) {
-		const block = this.options.elementAccessors.getBlock();
-		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) => this.lineGenerator(d));
-			if (block.transitionManager.durations.chartUpdate <= 0) resolve("");
-		});
-	}
-	getAllLinesWithNewData(stakedData, lineClass) {
-		const block = this.options.elementAccessors.getBlock();
-		return block.svg
-			.getChartGroup(this.chart.index)
-			.selectAll(`path.${lineClass}${Helper.getCssClassesLine(this.chart.cssClasses)}`)
-			.data(stakedData);
-	}
+    constructor(options, chart, lineGenerator) {
+        this.options = options;
+        this.chart = chart;
+        this.lineGenerator = lineGenerator;
+    }
+    renderSegmented(stakedData, lineClass) {
+        const block = this.options.elementAccessors.getBlock();
+        return block.svg
+            .getChartGroup(this.chart.index)
+            .selectAll(`.${lineClass}${Helper.getCssClassesLine(this.chart.cssClasses)}`)
+            .data(stakedData)
+            .enter()
+            .append("path")
+            .attr("d", (d) => this.lineGenerator(d))
+            .attr("class", lineClass)
+            .style("fill", "none")
+            .style("clip-path", `url(#${block.svg.getClipPathId()})`)
+            .style("pointer-events", "none");
+    }
+    setSegmentColor(segments, colorPalette) {
+        segments.style("stroke", (d, i) => colorPalette[i % colorPalette.length]);
+    }
+    updateSegmentedPath(linesObjects) {
+        const block = this.options.elementAccessors.getBlock();
+        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) => this.lineGenerator(d));
+            if (block.transitionManager.durations.chartUpdate <= 0)
+                resolve("");
+        });
+    }
+    getAllLinesWithNewData(stakedData, lineClass) {
+        const block = this.options.elementAccessors.getBlock();
+        return block.svg
+            .getChartGroup(this.chart.index)
+            .selectAll(`path.${lineClass}${Helper.getCssClassesLine(this.chart.cssClasses)}`)
+            .data(stakedData);
+    }
 }

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

@@ -2,11 +2,11 @@ import { MdtChartsDataRow } from "../../../config/config";
 import { LineLikeGeneratorMiddleware } from "../lineLike/generatorMiddleware/lineLikeGeneratorMiddleware";
 import { CoordinateGetter } from "../lineLike/generatorFactory/lineLikeGeneratorFactory";
 interface LineGeneratorOptions {
-	middlewares: LineLikeGeneratorMiddleware[];
+    middlewares: LineLikeGeneratorMiddleware[];
 }
 export declare class LineGenerator {
-	private options;
-	constructor(options: LineGeneratorOptions);
-	get(xValue: CoordinateGetter, yValue: CoordinateGetter): import("d3-shape").Line<MdtChartsDataRow>;
+    private options;
+    constructor(options: LineGeneratorOptions);
+    get(xValue: CoordinateGetter, yValue: CoordinateGetter): import("d3-shape").Line<MdtChartsDataRow>;
 }
 export {};

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

@@ -1,11 +1,11 @@
 import { line } from "d3-shape";
 export class LineGenerator {
-	constructor(options) {
-		this.options = options;
-	}
-	get(xValue, yValue) {
-		const generator = line().x(xValue).y(yValue);
-		this.options.middlewares.forEach((middleware) => middleware.handle(generator));
-		return generator;
-	}
+    constructor(options) {
+        this.options = options;
+    }
+    get(xValue, yValue) {
+        const generator = line().x(xValue).y(yValue);
+        this.options.middlewares.forEach((middleware) => middleware.handle(generator));
+        return generator;
+    }
 }

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

@@ -6,17 +6,11 @@ import { BaseType, Selection } from "d3-selection";
 import { Segment } from "../lineLike/generatorMiddleware/lineLikeGeneratorDefineMiddleware";
 import { LineLikeGeneratorFactoryOptions } from "../lineLike/generatorFactory/lineLikeGeneratorFactory";
 export declare class LineGeneratorFactory {
-	private options;
-	constructor(options: LineLikeGeneratorFactoryOptions);
-	getLineGenerator(valueFieldName: string): ILine<MdtChartsDataRow>;
-	getSegmentedLineGenerator(): ILine<MdtChartsDataRow>;
+    private options;
+    constructor(options: LineLikeGeneratorFactoryOptions);
+    getLineGenerator(valueFieldName: string): ILine<MdtChartsDataRow>;
+    getSegmentedLineGenerator(): ILine<MdtChartsDataRow>;
 }
-export declare function onLineChartInit(
-	creatingPipeline: Pipeline<Selection<SVGElement, any, BaseType, any>, TwoDimensionalChartModel>
-): void;
-export declare function applyLineDash(
-	lineSelection: Selection<SVGElement, any, BaseType, any>,
-	dashSize: number,
-	gapSize: number
-): Selection<SVGElement, any, BaseType, any>;
+export declare function onLineChartInit(creatingPipeline: Pipeline<Selection<SVGElement, any, BaseType, any>, TwoDimensionalChartModel>): void;
+export declare function applyLineDash(lineSelection: Selection<SVGElement, any, BaseType, any>, dashSize: number, gapSize: number): Selection<SVGElement, any, BaseType, any>;
 export declare function getStackedData(data: MdtChartsDataRow[], chart: TwoDimensionalChartModel): Segment[][];

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

@@ -4,88 +4,72 @@ import { LineGenerator } from "./lineGenerator";
 import { LineLikeGeneratorCurveMiddleware } from "../lineLike/generatorMiddleware/lineLikeGeneratorCurveMiddleware";
 import { LineLikeGeneratorDefinedMiddleware } from "../lineLike/generatorMiddleware/lineLikeGeneratorDefineMiddleware";
 export class LineGeneratorFactory {
-	constructor(options) {
-		this.options = options;
-	}
-	getLineGenerator(valueFieldName) {
-		const { keyAxisOrient, scales, keyFieldName, margin, shouldRender } = this.options;
-		const generator = new LineGenerator({
-			middlewares: [
-				new LineLikeGeneratorCurveMiddleware({ curve: this.options.curve }),
-				new LineLikeGeneratorDefinedMiddleware({
-					definedFn: shouldRender,
-					valueFieldNameGetter: () => valueFieldName,
-					dataRowGetter: (d) => d
-				})
-			]
-		});
-		if (keyAxisOrient === "bottom" || keyAxisOrient === "top") {
-			return generator.get(
-				(d) => Scale.getScaledValue(scales.key, d[keyFieldName]) + margin.left,
-				(d) => scales.value(d[valueFieldName]) + margin.top
-			);
-		}
-		if (keyAxisOrient === "left" || keyAxisOrient === "right") {
-			return generator.get(
-				(d) => scales.value(d[valueFieldName]) + margin.left,
-				(d) => Scale.getScaledValue(scales.key, d[keyFieldName]) + margin.top
-			);
-		}
-	}
-	getSegmentedLineGenerator() {
-		const { keyAxisOrient, scales, keyFieldName, margin, shouldRender } = this.options;
-		const generator = new LineGenerator({
-			middlewares: [
-				new LineLikeGeneratorCurveMiddleware({ curve: this.options.curve }),
-				new LineLikeGeneratorDefinedMiddleware({
-					definedFn: shouldRender,
-					valueFieldNameGetter: (d) => d.fieldName,
-					dataRowGetter: (d) => d.data
-				})
-			]
-		});
-		if (keyAxisOrient === "bottom" || keyAxisOrient === "top") {
-			return generator.get(
-				(d) => Scale.getScaledValue(scales.key, d.data[keyFieldName]) + margin.left,
-				(d) => scales.value(d[1]) + margin.top
-			);
-		}
-		if (keyAxisOrient === "left" || keyAxisOrient === "right") {
-			return generator.get(
-				(d) => scales.value(d[1]) + margin.left,
-				(d) => Scale.getScaledValue(scales.key, d.data[keyFieldName]) + margin.top
-			);
-		}
-	}
+    constructor(options) {
+        this.options = options;
+    }
+    getLineGenerator(valueFieldName) {
+        const { keyAxisOrient, scales, keyFieldName, margin, shouldRender } = this.options;
+        const generator = new LineGenerator({
+            middlewares: [
+                new LineLikeGeneratorCurveMiddleware({ curve: this.options.curve }),
+                new LineLikeGeneratorDefinedMiddleware({
+                    definedFn: shouldRender,
+                    valueFieldNameGetter: () => valueFieldName,
+                    dataRowGetter: (d) => d
+                })
+            ]
+        });
+        if (keyAxisOrient === "bottom" || keyAxisOrient === "top") {
+            return generator.get((d) => Scale.getScaledValue(scales.key, d[keyFieldName]) + margin.left, (d) => scales.value(d[valueFieldName]) + margin.top);
+        }
+        if (keyAxisOrient === "left" || keyAxisOrient === "right") {
+            return generator.get((d) => scales.value(d[valueFieldName]) + margin.left, (d) => Scale.getScaledValue(scales.key, d[keyFieldName]) + margin.top);
+        }
+    }
+    getSegmentedLineGenerator() {
+        const { keyAxisOrient, scales, keyFieldName, margin, shouldRender } = this.options;
+        const generator = new LineGenerator({
+            middlewares: [
+                new LineLikeGeneratorCurveMiddleware({ curve: this.options.curve }),
+                new LineLikeGeneratorDefinedMiddleware({
+                    definedFn: shouldRender,
+                    valueFieldNameGetter: (d) => d.fieldName,
+                    dataRowGetter: (d) => d.data
+                })
+            ]
+        });
+        if (keyAxisOrient === "bottom" || keyAxisOrient === "top") {
+            return generator.get((d) => Scale.getScaledValue(scales.key, d.data[keyFieldName]) + margin.left, (d) => scales.value(d[1]) + margin.top);
+        }
+        if (keyAxisOrient === "left" || keyAxisOrient === "right") {
+            return generator.get((d) => scales.value(d[1]) + margin.left, (d) => Scale.getScaledValue(scales.key, d.data[keyFieldName]) + margin.top);
+        }
+    }
 }
 export function onLineChartInit(creatingPipeline) {
-	creatingPipeline.push((path, chart) => {
-		if (chart.lineLikeViewOptions.dashedStyles.on) {
-			return applyLineDash(
-				path,
-				chart.lineLikeViewOptions.dashedStyles.dashSize,
-				chart.lineLikeViewOptions.dashedStyles.gapSize
-			);
-		}
-		return path;
-	});
-	creatingPipeline.push(setStrokeWidth);
+    creatingPipeline.push((path, chart) => {
+        if (chart.lineLikeViewOptions.dashedStyles.on) {
+            return applyLineDash(path, chart.lineLikeViewOptions.dashedStyles.dashSize, chart.lineLikeViewOptions.dashedStyles.gapSize);
+        }
+        return path;
+    });
+    creatingPipeline.push(setStrokeWidth);
 }
 function setStrokeWidth(path, chart) {
-	return path.style("stroke-width", chart.lineLikeViewOptions.strokeWidth);
+    return path.style("stroke-width", chart.lineLikeViewOptions.strokeWidth);
 }
 export function applyLineDash(lineSelection, dashSize, gapSize) {
-	return lineSelection.style("stroke-dasharray", `${dashSize} ${gapSize}`);
+    return lineSelection.style("stroke-dasharray", `${dashSize} ${gapSize}`);
 }
 export function getStackedData(data, chart) {
-	let stackedData = stack()
-		.keys(chart.data.valueFields.map((field) => field.name))(data)
-		.map((layer, index) => {
-			const fieldName = chart.data.valueFields[index].name;
-			return layer.map((segment) => {
-				segment.fieldName = fieldName;
-				return segment;
-			});
-		});
-	return stackedData;
+    let stackedData = stack()
+        .keys(chart.data.valueFields.map((field) => field.name))(data)
+        .map((layer, index) => {
+        const fieldName = chart.data.valueFields[index].name;
+        return layer.map((segment) => {
+            segment.fieldName = fieldName;
+            return segment;
+        });
+    });
+    return stackedData;
 }

package/lib/engine/twoDimensionalNotation/lineLike/generatorFactory/lineLikeGeneratorFactory.d.ts

@@ -3,10 +3,10 @@ import { BlockMargin, LineCurveType, LineLikeChartRenderFn, Orient } from "../..
 import { Scales } from "../../../features/scale/scale";
 export declare type CoordinateGetter = (dataRow: MdtChartsDataRow) => number;
 export interface LineLikeGeneratorFactoryOptions {
-	keyAxisOrient: Orient;
-	scales: Scales;
-	keyFieldName: string;
-	margin: BlockMargin;
-	curve: LineCurveType;
-	shouldRender: LineLikeChartRenderFn;
+    keyAxisOrient: Orient;
+    scales: Scales;
+    keyFieldName: string;
+    margin: BlockMargin;
+    curve: LineCurveType;
+    shouldRender: LineLikeChartRenderFn;
 }

package/lib/engine/twoDimensionalNotation/lineLike/generatorMiddleware/lineLikeGeneratorCurveMiddleware.d.ts

@@ -3,12 +3,12 @@ import { LineCurveType } from "../../../../model/model";
 import { LineLikeGeneratorMiddleware } from "./lineLikeGeneratorMiddleware";
 import { MdtChartsDataRow } from "../../../../main";
 interface LineLikeGeneratorCurveMiddlewareOptions {
-	curve?: LineCurveType;
+    curve?: LineCurveType;
 }
 export declare class LineLikeGeneratorCurveMiddleware implements LineLikeGeneratorMiddleware {
-	private options;
-	private readonly curvies;
-	constructor(options: LineLikeGeneratorCurveMiddlewareOptions);
-	handle(generator: Line<MdtChartsDataRow> | Area<MdtChartsDataRow>): Line<MdtChartsDataRow> | Area<MdtChartsDataRow>;
+    private options;
+    private readonly curvies;
+    constructor(options: LineLikeGeneratorCurveMiddlewareOptions);
+    handle(generator: Line<MdtChartsDataRow> | Area<MdtChartsDataRow>): Line<MdtChartsDataRow> | Area<MdtChartsDataRow>;
 }
 export {};

package/lib/engine/twoDimensionalNotation/lineLike/generatorMiddleware/lineLikeGeneratorCurveMiddleware.js

@@ -1,20 +1,21 @@
 import { curveBasis, curveMonotoneX, curveMonotoneY } from "d3-shape";
 import { LineCurveType } from "../../../../model/model";
 export class LineLikeGeneratorCurveMiddleware {
-	constructor(options) {
-		this.options = options;
-		this.curvies = {
-			[LineCurveType.monotoneX]: curveMonotoneX,
-			[LineCurveType.monotoneY]: curveMonotoneY,
-			[LineCurveType.basis]: curveBasis,
-			[LineCurveType.none]: undefined
-		};
-	}
-	handle(generator) {
-		if (this.options.curve != null) {
-			const curve = this.curvies[this.options.curve];
-			if (curve) generator.curve(curve);
-		}
-		return generator;
-	}
+    constructor(options) {
+        this.options = options;
+        this.curvies = {
+            [LineCurveType.monotoneX]: curveMonotoneX,
+            [LineCurveType.monotoneY]: curveMonotoneY,
+            [LineCurveType.basis]: curveBasis,
+            [LineCurveType.none]: undefined
+        };
+    }
+    handle(generator) {
+        if (this.options.curve != null) {
+            const curve = this.curvies[this.options.curve];
+            if (curve)
+                generator.curve(curve);
+        }
+        return generator;
+    }
 }

package/lib/engine/twoDimensionalNotation/lineLike/generatorMiddleware/lineLikeGeneratorDefineMiddleware.d.ts

@@ -4,18 +4,17 @@ import { MdtChartsDataRow } from "../../../../config/config";
 import { LineLikeChartRenderFn } from "../../../../model/model";
 import { SegmentWithFieldName } from "../../bar/stackedData/dataStacker";
 interface LineLikeGeneratorDefinedMiddlewareOptions {
-	definedFn: LineLikeChartRenderFn;
-	valueFieldNameGetter: (d: MdtChartsDataRow | Segment) => string;
-	dataRowGetter: (d: MdtChartsDataRow | Segment) => MdtChartsDataRow;
+    definedFn: LineLikeChartRenderFn;
+    valueFieldNameGetter: (d: MdtChartsDataRow | Segment) => string;
+    dataRowGetter: (d: MdtChartsDataRow | Segment) => MdtChartsDataRow;
+}
+export interface Segment extends SeriesPoint<{
+    [p: string]: number;
+}>, SegmentWithFieldName {
 }
-export interface Segment
-	extends SeriesPoint<{
-			[p: string]: number;
-		}>,
-		SegmentWithFieldName {}
 export declare class LineLikeGeneratorDefinedMiddleware implements LineLikeGeneratorMiddleware {
-	private readonly options;
-	constructor(options: LineLikeGeneratorDefinedMiddlewareOptions);
-	handle(generator: Line<MdtChartsDataRow> | Area<MdtChartsDataRow>): Line<MdtChartsDataRow> | Area<MdtChartsDataRow>;
+    private readonly options;
+    constructor(options: LineLikeGeneratorDefinedMiddlewareOptions);
+    handle(generator: Line<MdtChartsDataRow> | Area<MdtChartsDataRow>): Line<MdtChartsDataRow> | Area<MdtChartsDataRow>;
 }
 export {};

package/lib/engine/twoDimensionalNotation/lineLike/generatorMiddleware/lineLikeGeneratorDefineMiddleware.js

@@ -1,11 +1,9 @@
 export class LineLikeGeneratorDefinedMiddleware {
-	constructor(options) {
-		this.options = options;
-	}
-	handle(generator) {
-		generator.defined((d) =>
-			this.options.definedFn(this.options.dataRowGetter(d), this.options.valueFieldNameGetter(d))
-		);
-		return generator;
-	}
+    constructor(options) {
+        this.options = options;
+    }
+    handle(generator) {
+        generator.defined((d) => this.options.definedFn(this.options.dataRowGetter(d), this.options.valueFieldNameGetter(d)));
+        return generator;
+    }
 }

package/lib/engine/twoDimensionalNotation/lineLike/generatorMiddleware/lineLikeGeneratorMiddleware.d.ts

@@ -1,7 +1,5 @@
 import { Line as ILine, Area as IArea } from "d3-shape";
 import { MdtChartsDataRow } from "../../../../config/config";
 export interface LineLikeGeneratorMiddleware {
-	handle(
-		generator: ILine<MdtChartsDataRow> | IArea<MdtChartsDataRow>
-	): ILine<MdtChartsDataRow> | IArea<MdtChartsDataRow>;
+    handle(generator: ILine<MdtChartsDataRow> | IArea<MdtChartsDataRow>): ILine<MdtChartsDataRow> | IArea<MdtChartsDataRow>;
 }

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

@@ -3,15 +3,15 @@ import { Model, TwoDimensionalOptionsModel } from "../../model/model";
 import { Block } from "../block/block";
 import { ChartContentManager } from "../contentManager/contentManagerFactory";
 import { Engine } from "../engine";
-import { FilterEventManager } from "../filterManager/filterEventManager";
+import { ChartClearSelectionOptions, FilterEventManager } from "../filterManager/filterEventManager";
 export declare class TwoDimensionalManager implements ChartContentManager {
-	private canvasValueLabels?;
-	private linearGradientDef?;
-	private dotChart;
-	render(engine: Engine, model: Model<TwoDimensionalOptionsModel>): void;
-	updateData(block: Block, model: Model<TwoDimensionalOptionsModel>, data: MdtChartsDataSource): void;
-	updateColors(block: Block, model: Model<TwoDimensionalOptionsModel>): void;
-	clearSelection(filterEventManager: FilterEventManager, model: Model<TwoDimensionalOptionsModel>): void;
-	private renderCharts;
-	private updateCharts;
+    private canvasValueLabels?;
+    private linearGradientDef?;
+    private dotChart;
+    render(engine: Engine, model: Model<TwoDimensionalOptionsModel>): void;
+    updateData(block: Block, model: Model<TwoDimensionalOptionsModel>, data: MdtChartsDataSource): void;
+    updateColors(block: Block, model: Model<TwoDimensionalOptionsModel>): void;
+    clearSelection(filterEventManager: FilterEventManager, model: Model<TwoDimensionalOptionsModel>, options?: ChartClearSelectionOptions): void;
+    private renderCharts;
+    private updateCharts;
 }