mdt-charts 1.28.1 → 1.29.0

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

@@ -4,72 +4,88 @@ 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,21 +1,20 @@
 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,17 +4,18 @@ 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;
-}
-export interface Segment extends SeriesPoint<{
-    [p: string]: number;
-}>, SegmentWithFieldName {
+	definedFn: LineLikeChartRenderFn;
+	valueFieldNameGetter: (d: MdtChartsDataRow | Segment) => string;
+	dataRowGetter: (d: MdtChartsDataRow | Segment) => MdtChartsDataRow;
 }
+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,9 +1,11 @@
 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,5 +1,7 @@
 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

@@ -5,13 +5,13 @@ import { ChartContentManager } from "../contentManager/contentManagerFactory";
 import { Engine } from "../engine";
 import { 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>): void;
+	private renderCharts;
+	private updateCharts;
 }