mdt-charts 1.28.2 → 1.29.0

package/lib/model/modelInstance/titleConfigReader.js

@@ -1,33 +1,40 @@
 import { ModelHelper } from "../helpers/modelHelper";
 export class TitleConfigReader {
-    constructor(config, dataGetter, defaultCssUnitReader) {
-        this.config = config;
-        this.dataGetter = dataGetter;
-        this.defaultCssUnitReader = defaultCssUnitReader;
-    }
-    static create(config, modelInstance) {
-        return new TitleConfigReader(config, () => modelInstance.dataModel.repository.getRawRows(), () => ModelHelper.getFontSizeCssValue("--chart-title-font-size", 16));
-    }
-    getTextContent() {
-        return this.getResolvedTitle();
-    }
-    getFontSize() {
-        var _a;
-        return typeof this.config === "object"
-            ? (_a = this.config.fontSize) !== null && _a !== void 0 ? _a : this.defaultCssUnitReader() : this.defaultCssUnitReader();
-    }
-    getResolvedTitle() {
-        switch (typeof this.config) {
-            case "string":
-                return this.config;
-            case "function":
-                return this.config({ data: this.dataGetter() });
-            case "object":
-                return typeof this.config.text === "function"
-                    ? this.config.text({ data: this.dataGetter() })
-                    : this.config.text;
-            default:
-                return "";
-        }
-    }
+	constructor(config, dataGetter, defaultCssUnitReader) {
+		this.config = config;
+		this.dataGetter = dataGetter;
+		this.defaultCssUnitReader = defaultCssUnitReader;
+	}
+	static create(config, modelInstance) {
+		return new TitleConfigReader(
+			config,
+			() => modelInstance.dataModel.repository.getRawRows(),
+			() => ModelHelper.getFontSizeCssValue("--chart-title-font-size", 16)
+		);
+	}
+	getTextContent() {
+		return this.getResolvedTitle();
+	}
+	getFontSize() {
+		var _a;
+		return typeof this.config === "object"
+			? (_a = this.config.fontSize) !== null && _a !== void 0
+				? _a
+				: this.defaultCssUnitReader()
+			: this.defaultCssUnitReader();
+	}
+	getResolvedTitle() {
+		switch (typeof this.config) {
+			case "string":
+				return this.config;
+			case "function":
+				return this.config({ data: this.dataGetter() });
+			case "object":
+				return typeof this.config.text === "function"
+					? this.config.text({ data: this.dataGetter() })
+					: this.config.text;
+			default:
+				return "";
+		}
+	}
 }

package/lib/model/notations/polar/donut/donutAggregatorService.d.ts

@@ -2,12 +2,15 @@ import { MdtChartsDataRow, MdtChartsDonutAggregator } from "../../../../config/c
 import { DonutAggregatorContent } from "../../../model";
 export declare const AGGREGATOR_DEFAULT_TITLE = "\u0421\u0443\u043C\u043C\u0430";
 export interface AggregatorServiceDataOptions {
-    rows: MdtChartsDataRow[];
-    valueFieldName: string;
+	rows: MdtChartsDataRow[];
+	valueFieldName: string;
 }
 export declare class DonutAggregatorService {
-    getContent(aggregatorOptions: MdtChartsDonutAggregator, dataOptions: AggregatorServiceDataOptions): DonutAggregatorContent;
-    private doesValueExist;
-    private generateDefaultContent;
-    private getDefaultValue;
+	getContent(
+		aggregatorOptions: MdtChartsDonutAggregator,
+		dataOptions: AggregatorServiceDataOptions
+	): DonutAggregatorContent;
+	private doesValueExist;
+	private generateDefaultContent;
+	private getDefaultValue;
 }

package/lib/model/notations/polar/donut/donutAggregatorService.js

@@ -1,40 +1,43 @@
 export const AGGREGATOR_DEFAULT_TITLE = "Сумма";
 export class DonutAggregatorService {
-    getContent(aggregatorOptions, dataOptions) {
-        if (!(aggregatorOptions === null || aggregatorOptions === void 0 ? void 0 : aggregatorOptions.content) || !dataOptions.rows)
-            return this.generateDefaultContent(dataOptions);
-        const content = aggregatorOptions.content({ data: dataOptions.rows });
-        if (!content || (!this.doesValueExist(content.value) && !content.title))
-            return this.generateDefaultContent(dataOptions);
-        if (this.doesValueExist(content.value) && content.title) {
-            return {
-                title: content.title,
-                value: content.value
-            };
-        }
-        if (!content.title && this.doesValueExist(content.value))
-            return {
-                value: content.value,
-                title: AGGREGATOR_DEFAULT_TITLE
-            };
-        if (!this.doesValueExist(content.value) && content.title) {
-            return {
-                value: this.getDefaultValue(dataOptions),
-                title: content.title
-            };
-        }
-    }
-    doesValueExist(content) {
-        return content != null;
-    }
-    generateDefaultContent(dataOptions) {
-        return {
-            title: AGGREGATOR_DEFAULT_TITLE,
-            value: dataOptions.rows ? this.getDefaultValue(dataOptions) : 0
-        };
-    }
-    getDefaultValue(dataOptions) {
-        const totalSumOfValues = dataOptions.rows.reduce((acc, row) => acc + row[dataOptions.valueFieldName], 0);
-        return totalSumOfValues;
-    }
+	getContent(aggregatorOptions, dataOptions) {
+		if (
+			!(aggregatorOptions === null || aggregatorOptions === void 0 ? void 0 : aggregatorOptions.content) ||
+			!dataOptions.rows
+		)
+			return this.generateDefaultContent(dataOptions);
+		const content = aggregatorOptions.content({ data: dataOptions.rows });
+		if (!content || (!this.doesValueExist(content.value) && !content.title))
+			return this.generateDefaultContent(dataOptions);
+		if (this.doesValueExist(content.value) && content.title) {
+			return {
+				title: content.title,
+				value: content.value
+			};
+		}
+		if (!content.title && this.doesValueExist(content.value))
+			return {
+				value: content.value,
+				title: AGGREGATOR_DEFAULT_TITLE
+			};
+		if (!this.doesValueExist(content.value) && content.title) {
+			return {
+				value: this.getDefaultValue(dataOptions),
+				title: content.title
+			};
+		}
+	}
+	doesValueExist(content) {
+		return content != null;
+	}
+	generateDefaultContent(dataOptions) {
+		return {
+			title: AGGREGATOR_DEFAULT_TITLE,
+			value: dataOptions.rows ? this.getDefaultValue(dataOptions) : 0
+		};
+	}
+	getDefaultValue(dataOptions) {
+		const totalSumOfValues = dataOptions.rows.reduce((acc, row) => acc + row[dataOptions.valueFieldName], 0);
+		return totalSumOfValues;
+	}
 }

package/lib/model/notations/polar/donut/donutModel.d.ts

@@ -2,9 +2,13 @@ import { MdtChartsDataRow, PolarChart } from "../../../../config/config";
 import { DonutOptionsCanvas } from "../../../../designer/designerConfig";
 import { DonutChartSettings } from "../../../model";
 export declare class DonutModel {
-    private thicknessService;
-    private aggregatorService;
-    getSettings(settingsFromConfig: DonutOptionsCanvas, chartOptions: PolarChart, rawDataRows: MdtChartsDataRow[]): DonutChartSettings;
-    private getThicknessOptions;
-    private getAggregatorOptions;
+	private thicknessService;
+	private aggregatorService;
+	getSettings(
+		settingsFromConfig: DonutOptionsCanvas,
+		chartOptions: PolarChart,
+		rawDataRows: MdtChartsDataRow[]
+	): DonutChartSettings;
+	private getThicknessOptions;
+	private getAggregatorOptions;
 }

package/lib/model/notations/polar/donut/donutModel.js

@@ -1,32 +1,32 @@
 import { DonutAggregatorService } from "./donutAggregatorService";
 import { DonutThicknessService } from "./donutThicknessService";
 export class DonutModel {
-    constructor() {
-        this.thicknessService = new DonutThicknessService();
-        this.aggregatorService = new DonutAggregatorService();
-    }
-    getSettings(settingsFromConfig, chartOptions, rawDataRows) {
-        return {
-            padAngle: settingsFromConfig.padAngle,
-            thickness: this.getThicknessOptions(settingsFromConfig.thickness),
-            aggregator: this.getAggregatorOptions(settingsFromConfig, chartOptions, rawDataRows)
-        };
-    }
-    getThicknessOptions(settingsFromConfig) {
-        return {
-            unit: this.thicknessService.getUnit(settingsFromConfig),
-            max: this.thicknessService.valueToNumber(settingsFromConfig.max),
-            min: this.thicknessService.valueToNumber(settingsFromConfig.min),
-            value: this.thicknessService.valueToNumber(settingsFromConfig.value)
-        };
-    }
-    getAggregatorOptions(settingsFromConfig, chartOptions, rawDataRows) {
-        return {
-            margin: settingsFromConfig.aggregatorPad,
-            content: this.aggregatorService.getContent(chartOptions.aggregator, {
-                rows: rawDataRows,
-                valueFieldName: chartOptions.data.valueField.name
-            })
-        };
-    }
+	constructor() {
+		this.thicknessService = new DonutThicknessService();
+		this.aggregatorService = new DonutAggregatorService();
+	}
+	getSettings(settingsFromConfig, chartOptions, rawDataRows) {
+		return {
+			padAngle: settingsFromConfig.padAngle,
+			thickness: this.getThicknessOptions(settingsFromConfig.thickness),
+			aggregator: this.getAggregatorOptions(settingsFromConfig, chartOptions, rawDataRows)
+		};
+	}
+	getThicknessOptions(settingsFromConfig) {
+		return {
+			unit: this.thicknessService.getUnit(settingsFromConfig),
+			max: this.thicknessService.valueToNumber(settingsFromConfig.max),
+			min: this.thicknessService.valueToNumber(settingsFromConfig.min),
+			value: this.thicknessService.valueToNumber(settingsFromConfig.value)
+		};
+	}
+	getAggregatorOptions(settingsFromConfig, chartOptions, rawDataRows) {
+		return {
+			margin: settingsFromConfig.aggregatorPad,
+			content: this.aggregatorService.getContent(chartOptions.aggregator, {
+				rows: rawDataRows,
+				valueFieldName: chartOptions.data.valueField.name
+			})
+		};
+	}
 }

package/lib/model/notations/polar/donut/donutThicknessService.d.ts

@@ -1,7 +1,7 @@
 import { MdtChartsDonutThicknessOptions } from "../../../../designer/designerConfig";
 import { DonutThicknessUnit } from "../../../model";
 export declare class DonutThicknessService {
-    private defaultUnit;
-    getUnit(settingsFromConfig: MdtChartsDonutThicknessOptions): DonutThicknessUnit;
-    valueToNumber(value: string | number): number;
+	private defaultUnit;
+	getUnit(settingsFromConfig: MdtChartsDonutThicknessOptions): DonutThicknessUnit;
+	valueToNumber(value: string | number): number;
 }

package/lib/model/notations/polar/donut/donutThicknessService.js

@@ -1,18 +1,16 @@
 import { getPxPercentUnitByValue } from "../../../helpers/unitsFromConfigReader";
 export class DonutThicknessService {
-    constructor() {
-        this.defaultUnit = "px";
-    }
-    getUnit(settingsFromConfig) {
-        if (settingsFromConfig.value)
-            return getPxPercentUnitByValue(settingsFromConfig.value);
-        const minUnit = getPxPercentUnitByValue(settingsFromConfig.min);
-        const maxUnit = getPxPercentUnitByValue(settingsFromConfig.max);
-        return minUnit === maxUnit ? minUnit : this.defaultUnit;
-    }
-    valueToNumber(value) {
-        if (typeof value === "number")
-            return value;
-        return parseInt(value);
-    }
+	constructor() {
+		this.defaultUnit = "px";
+	}
+	getUnit(settingsFromConfig) {
+		if (settingsFromConfig.value) return getPxPercentUnitByValue(settingsFromConfig.value);
+		const minUnit = getPxPercentUnitByValue(settingsFromConfig.min);
+		const maxUnit = getPxPercentUnitByValue(settingsFromConfig.max);
+		return minUnit === maxUnit ? minUnit : this.defaultUnit;
+	}
+	valueToNumber(value) {
+		if (typeof value === "number") return value;
+		return parseInt(value);
+	}
 }

package/lib/model/notations/polar/polarModel.d.ts

@@ -5,11 +5,22 @@ import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
 import { ModelInstance } from "../../modelInstance/modelInstance";
 export declare const MIN_DONUT_BLOCK_SIZE = 120;
 export declare class PolarModel {
-    private static donutModel;
-    static getOptions(options: MdtChartsPolarOptions, designerConfig: DesignerConfig, modelInstance: ModelInstance): PolarOptionsModel;
-    static getLegendPositionByBlockSize(canvasModel: CanvasModel): "bottom" | "right";
-    static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth: number, legendWidth: number, legendCoordinate: LegendCoordinate): boolean;
-    static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight: number, legendCoordinate: LegendCoordinate): boolean;
-    private static getDonutSettings;
-    private static getChartsModel;
+	private static donutModel;
+	static getOptions(
+		options: MdtChartsPolarOptions,
+		designerConfig: DesignerConfig,
+		modelInstance: ModelInstance
+	): PolarOptionsModel;
+	static getLegendPositionByBlockSize(canvasModel: CanvasModel): "bottom" | "right";
+	static doesChartBlockHasEnoughWidthForContainsLegend(
+		chartBlockWidth: number,
+		legendWidth: number,
+		legendCoordinate: LegendCoordinate
+	): boolean;
+	static doesChartBlockHasEnoughHeightForContainsLegend(
+		chartBlockHeight: number,
+		legendCoordinate: LegendCoordinate
+	): boolean;
+	private static getDonutSettings;
+	private static getChartsModel;
 }

package/lib/model/notations/polar/polarModel.js

@@ -3,70 +3,84 @@ import { DonutModel } from "./donut/donutModel";
 import { TitleConfigReader } from "../../modelInstance/titleConfigReader";
 export const MIN_DONUT_BLOCK_SIZE = 120;
 export class PolarModel {
-    static getOptions(options, designerConfig, modelInstance) {
-        const titleConfig = TitleConfigReader.create(options.title, modelInstance);
-        return {
-            type: options.type,
-            selectable: !!options.selectable,
-            title: {
-                textContent: titleConfig.getTextContent(),
-                fontSize: titleConfig.getFontSize()
-            },
-            data: Object.assign({}, options.data),
-            charts: this.getChartsModel(options.chart, modelInstance.dataModel.repository.getScopedRows().length, designerConfig.chartStyle),
-            legend: modelInstance.canvasModel.legendCanvas.getModel(),
-            tooltip: options.tooltip,
-            chartCanvas: this.getDonutSettings(designerConfig.canvas.chartOptions.donut, options.chart, modelInstance.dataModel.repository.getRawRows()),
-            defs: { gradients: [] }
-        };
-    }
-    //TODO: type for returned value
-    static getLegendPositionByBlockSize(canvasModel) {
-        const widthCoefficientWhenLegendShouldInBottom = 1.5;
-        const avgLegendWidth = 100;
-        const blockWidth = canvasModel.getBlockSize().width;
-        const blockHeight = canvasModel.getBlockSize().height;
-        return canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE + avgLegendWidth &&
-            blockWidth * widthCoefficientWhenLegendShouldInBottom < blockHeight
-            ? "bottom"
-            : "right";
-    }
-    static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth, legendWidth, legendCoordinate) {
-        const rightLegendMargin = legendCoordinate.right.margin;
-        return chartBlockWidth - legendWidth - rightLegendMargin.left - rightLegendMargin.right >= MIN_DONUT_BLOCK_SIZE;
-    }
-    static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight, legendCoordinate) {
-        const minHeightForLegend = 30;
-        const bottomLegendMargin = legendCoordinate.bottom.margin;
-        const heightForLegend = chartBlockHeight - bottomLegendMargin.bottom - bottomLegendMargin.top - MIN_DONUT_BLOCK_SIZE;
-        return heightForLegend >= minHeightForLegend;
-    }
-    static getDonutSettings(settings, chartOptions, dataRows) {
-        return this.donutModel.getSettings(settings, chartOptions, dataRows);
-    }
-    static getChartsModel(chart, dataLength, chartStyleConfig) {
-        const chartsModel = [];
-        chartsModel.push({
-            type: chart.type,
-            data: Object.assign({}, chart.data),
-            tooltip: { show: true },
-            cssClasses: ChartStyleModelService.getCssClasses(0),
-            style: ChartStyleModelService.getChartStyle(dataLength, chartStyleConfig),
-            legend: {
-                markerShape: "default",
-                barViewOptions: {
-                    hatch: { on: false },
-                    borderRadius: { topLeft: 0, topRight: 0, bottomLeft: 0, bottomRight: 0 },
-                    width: 0
-                },
-                lineViewOptions: {
-                    dashedStyles: { on: false, dashSize: 0, gapSize: 0 },
-                    strokeWidth: 0,
-                    length: 0
-                }
-            }
-        });
-        return chartsModel;
-    }
+	static getOptions(options, designerConfig, modelInstance) {
+		const titleConfig = TitleConfigReader.create(options.title, modelInstance);
+		return {
+			type: options.type,
+			selectable: !!options.selectable,
+			title: {
+				textContent: titleConfig.getTextContent(),
+				fontSize: titleConfig.getFontSize()
+			},
+			data: Object.assign({}, options.data),
+			charts: this.getChartsModel(
+				options.chart,
+				modelInstance.dataModel.repository.getScopedRows().length,
+				designerConfig.chartStyle
+			),
+			legend: modelInstance.canvasModel.legendCanvas.getModel(),
+			tooltip: options.tooltip,
+			chartCanvas: this.getDonutSettings(
+				designerConfig.canvas.chartOptions.donut,
+				options.chart,
+				modelInstance.dataModel.repository.getRawRows()
+			),
+			defs: { gradients: [] }
+		};
+	}
+	//TODO: type for returned value
+	static getLegendPositionByBlockSize(canvasModel) {
+		const widthCoefficientWhenLegendShouldInBottom = 1.5;
+		const avgLegendWidth = 100;
+		const blockWidth = canvasModel.getBlockSize().width;
+		const blockHeight = canvasModel.getBlockSize().height;
+		return canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE + avgLegendWidth &&
+			blockWidth * widthCoefficientWhenLegendShouldInBottom < blockHeight
+			? "bottom"
+			: "right";
+	}
+	static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth, legendWidth, legendCoordinate) {
+		const rightLegendMargin = legendCoordinate.right.margin;
+		return chartBlockWidth - legendWidth - rightLegendMargin.left - rightLegendMargin.right >= MIN_DONUT_BLOCK_SIZE;
+	}
+	static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight, legendCoordinate) {
+		const minHeightForLegend = 30;
+		const bottomLegendMargin = legendCoordinate.bottom.margin;
+		const heightForLegend =
+			chartBlockHeight - bottomLegendMargin.bottom - bottomLegendMargin.top - MIN_DONUT_BLOCK_SIZE;
+		return heightForLegend >= minHeightForLegend;
+	}
+	static getDonutSettings(settings, chartOptions, dataRows) {
+		return this.donutModel.getSettings(settings, chartOptions, dataRows);
+	}
+	static getChartsModel(chart, dataLength, chartStyleConfig) {
+		const chartsModel = [];
+		chartsModel.push({
+			type: chart.type,
+			data: Object.assign({}, chart.data),
+			tooltip: { show: true },
+			cssClasses: ChartStyleModelService.getCssClasses(0),
+			style: ChartStyleModelService.getChartStyle(dataLength, chartStyleConfig),
+			legend: {
+				markerShape: "default",
+				barViewOptions: {
+					hatch: { on: false },
+					borderRadius: {
+						topLeft: 0,
+						topRight: 0,
+						bottomLeft: 0,
+						bottomRight: 0
+					},
+					width: 0
+				},
+				lineViewOptions: {
+					dashedStyles: { on: false, dashSize: 0, gapSize: 0 },
+					strokeWidth: 0,
+					length: 0
+				}
+			}
+		});
+		return chartsModel;
+	}
 }
 PolarModel.donutModel = new DonutModel();

package/lib/model/notations/twoDimensional/styles.d.ts

@@ -1,14 +1,51 @@
-import { AreaChartViewOptions, BarBorderRadius, ChartLegendModel, ChartStyle, GradientId, LineLikeChartDashOptions, LineLikeChartShapeOptions, Orient, TwoDimensionalBarLikeChartViewModel, TwoDimensionalChartLegendLineModel } from "../../model";
-import { ChartOrientation, MdtChartsLineLikeChartDashedStyles, MdtChartsTwoDimensionalChart, TwoDimensionalChartType } from "../../../config/config";
+import {
+	AreaChartViewOptions,
+	BarBorderRadius,
+	ChartLegendModel,
+	ChartStyle,
+	GradientId,
+	LineLikeChartDashOptions,
+	LineLikeChartShapeOptions,
+	Orient,
+	TwoDimensionalBarLikeChartViewModel,
+	TwoDimensionalChartLegendLineModel
+} from "../../model";
+import {
+	ChartOrientation,
+	MdtChartsLineLikeChartDashedStyles,
+	MdtChartsTwoDimensionalChart,
+	TwoDimensionalChartType
+} from "../../../config/config";
 import { MdtChartsLineLikeChartShape } from "../../../designer/designerConfig";
 export declare const LINE_CHART_DEFAULT_WIDTH = 2;
-export declare function parseShape(chartOrientation: ChartOrientation, configOptions?: MdtChartsLineLikeChartShape): LineLikeChartShapeOptions;
+export declare function parseShape(
+	chartOrientation: ChartOrientation,
+	configOptions?: MdtChartsLineLikeChartShape
+): LineLikeChartShapeOptions;
 export declare function parseDashStyles(configOptions?: MdtChartsLineLikeChartDashedStyles): LineLikeChartDashOptions;
-export declare function getBarViewOptions(chart: MdtChartsTwoDimensionalChart, keyAxisOrient: Orient, barIndexes: number[]): TwoDimensionalBarLikeChartViewModel;
-export declare function calculateBarIndexes(allCharts: Pick<MdtChartsTwoDimensionalChart, "isSegmented" | "data" | "type">[], currentChart: Pick<MdtChartsTwoDimensionalChart, "isSegmented" | "data" | "type">, currentChartIndex: number): number[];
-export declare function getSegmentedRadiusValues(segmentsLength: number, segmentIndex: number, keyAxisOrient: Orient, defaultRadius: number): BarBorderRadius;
+export declare function getBarViewOptions(
+	chart: MdtChartsTwoDimensionalChart,
+	keyAxisOrient: Orient,
+	barIndexes: number[]
+): TwoDimensionalBarLikeChartViewModel;
+export declare function calculateBarIndexes(
+	allCharts: Pick<MdtChartsTwoDimensionalChart, "isSegmented" | "data" | "type">[],
+	currentChart: Pick<MdtChartsTwoDimensionalChart, "isSegmented" | "data" | "type">,
+	currentChartIndex: number
+): number[];
+export declare function getSegmentedRadiusValues(
+	segmentsLength: number,
+	segmentIndex: number,
+	keyAxisOrient: Orient,
+	defaultRadius: number
+): BarBorderRadius;
 export declare function getLegendMarkerOptions(chart: MdtChartsTwoDimensionalChart): ChartLegendModel;
 export declare function getLineViewOptions(chart: MdtChartsTwoDimensionalChart): TwoDimensionalChartLegendLineModel;
 export declare function getWidthOfLegendMarkerByType(chartType: TwoDimensionalChartType): number;
-export declare function getAreaViewOptions(chart: MdtChartsTwoDimensionalChart, chartIndex: number, style: ChartStyle, chartBlockId: number): AreaChartViewOptions;
+export declare function getAreaViewOptions(
+	chart: MdtChartsTwoDimensionalChart,
+	chartIndex: number,
+	style: ChartStyle,
+	chartBlockId: number
+): AreaChartViewOptions;
 export declare function getGradientId(chartIndex: number, subIndex: number, chartBlockId: number): GradientId;