mdt-charts 1.29.0 → 1.30.0

package/lib/model/featuresModel/scaleModel/scaleDomainService.js

@@ -1,50 +1,61 @@
 export function getResolvedDomain(domain, dataRows) {
-	return typeof domain === "function" ? domain({ data: dataRows }) : domain;
+    return typeof domain === "function" ? domain({ data: dataRows }) : domain;
 }
 export function getScaleLinearDomain(configDomain, dataRows, configOptions, valueGroup = "main") {
-	const calculator = new ScaleDomainCalculator();
-	let domainPeekMin;
-	let domainPeekMax;
-	const resolvedConfigDomain = getResolvedDomain(configDomain, dataRows);
-	const charts = configOptions.charts.filter((chart) => {
-		var _a;
-		return ((_a = chart.data.valueGroup) !== null && _a !== void 0 ? _a : "main") === valueGroup;
-	});
-	if (resolvedConfigDomain.start === -1) domainPeekMin = calculator.getScaleMinValue(configOptions.charts, dataRows);
-	else domainPeekMin = resolvedConfigDomain.start;
-	if (resolvedConfigDomain.end === -1) domainPeekMax = calculator.getScaleMaxValue(charts, dataRows);
-	else domainPeekMax = resolvedConfigDomain.end;
-	if (configOptions.axis.key.position === "start") return [domainPeekMin, domainPeekMax];
-	return [domainPeekMax, domainPeekMin];
+    const calculator = new ScaleDomainCalculator();
+    let domainPeekMin;
+    let domainPeekMax;
+    const resolvedConfigDomain = getResolvedDomain(configDomain, dataRows);
+    const charts = configOptions.charts.filter((chart) => {
+        var _a;
+        return ((_a = chart.data.valueGroup) !== null && _a !== void 0 ? _a : "main") === valueGroup;
+    });
+    if (resolvedConfigDomain.start === -1)
+        domainPeekMin = calculator.getScaleMinValue(configOptions.charts, dataRows);
+    else
+        domainPeekMin = resolvedConfigDomain.start;
+    if (resolvedConfigDomain.end === -1)
+        domainPeekMax = calculator.getScaleMaxValue(charts, dataRows);
+    else
+        domainPeekMax = resolvedConfigDomain.end;
+    if (configOptions.axis.key.position === "start")
+        return [domainPeekMin, domainPeekMax];
+    return [domainPeekMax, domainPeekMin];
 }
 export class ScaleDomainCalculator {
-	getScaleMinValue(charts, dataRows) {
-		let min = 0;
-		charts.forEach((chart) => {
-			dataRows.forEach((dataRow) => {
-				let sumInRow = 0;
-				chart.data.valueFields.forEach((field) => {
-					if (chart.isSegmented && dataRow[field.name] < 0) {
-						sumInRow += dataRow[field.name];
-					} else if (dataRow[field.name] < sumInRow) sumInRow = dataRow[field.name];
-				});
-				if (min > sumInRow) min = sumInRow;
-			});
-		});
-		return min;
-	}
-	getScaleMaxValue(charts, dataRows) {
-		let max = 0;
-		charts.forEach((chart) => {
-			dataRows.forEach((dataRow) => {
-				let sumInRow = 0;
-				chart.data.valueFields.forEach((field) => {
-					if (chart.isSegmented && dataRow[field.name] > 0) sumInRow += dataRow[field.name];
-					else if (dataRow[field.name] > sumInRow) sumInRow = dataRow[field.name];
-				});
-				if (max < sumInRow) max = sumInRow;
-			});
-		});
-		return max;
-	}
+    getScaleMinValue(charts, dataRows) {
+        let min = 0;
+        charts.forEach((chart) => {
+            dataRows.forEach((dataRow) => {
+                let sumInRow = 0;
+                chart.data.valueFields.forEach((field) => {
+                    if (chart.isSegmented && dataRow[field.name] < 0) {
+                        sumInRow += dataRow[field.name];
+                    }
+                    else if (dataRow[field.name] < sumInRow)
+                        sumInRow = dataRow[field.name];
+                });
+                if (min > sumInRow)
+                    min = sumInRow;
+            });
+        });
+        return min;
+    }
+    getScaleMaxValue(charts, dataRows) {
+        let max = 0;
+        charts.forEach((chart) => {
+            dataRows.forEach((dataRow) => {
+                let sumInRow = 0;
+                chart.data.valueFields.forEach((field) => {
+                    if (chart.isSegmented && dataRow[field.name] > 0)
+                        sumInRow += dataRow[field.name];
+                    else if (dataRow[field.name] > sumInRow)
+                        sumInRow = dataRow[field.name];
+                });
+                if (max < sumInRow)
+                    max = sumInRow;
+            });
+        });
+        return max;
+    }
 }

package/lib/model/featuresModel/scaleModel/scaleModel.d.ts

@@ -3,16 +3,16 @@ import { MdtChartsTwoDimensionalOptions, MdtChartsDataRow } from "../../../confi
 import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
 import { TwoDimConfigReader } from "../../modelInstance/configReader";
 export declare enum ScaleType {
-	Key = 0,
-	Value = 1
+    Key = 0,
+    Value = 1
 }
 export declare class ScaleModel {
-	private readonly options;
-	private readonly canvasModel;
-	constructor(options: MdtChartsTwoDimensionalOptions, canvasModel: CanvasModel);
-	getScaleKey(allowableKeys: string[]): ScaleKeyModel;
-	getScaleLinear(dataRows: MdtChartsDataRow[], configReader?: TwoDimConfigReader): ScaleValueModel;
-	getScaleSecondaryLinear(dataRows: MdtChartsDataRow[], configReader?: TwoDimConfigReader): ScaleValueModel;
-	private getChartsByTypes;
-	private getScaleKeyType;
+    private readonly options;
+    private readonly canvasModel;
+    constructor(options: MdtChartsTwoDimensionalOptions, canvasModel: CanvasModel);
+    getScaleKey(allowableKeys: string[]): ScaleKeyModel;
+    getScaleLinear(dataRows: MdtChartsDataRow[], configReader?: TwoDimConfigReader): ScaleValueModel;
+    getScaleSecondaryLinear(dataRows: MdtChartsDataRow[], configReader?: TwoDimConfigReader): ScaleValueModel;
+    private getChartsByTypes;
+    private getScaleKeyType;
 }

package/lib/model/featuresModel/scaleModel/scaleModel.js

@@ -2,67 +2,56 @@ import { getElementsAmountForScale, getScaleKeyRangePeek, getScaleValueRangePeek
 import { getScaleLinearDomain } from "./scaleDomainService";
 export var ScaleType;
 (function (ScaleType) {
-	ScaleType[(ScaleType["Key"] = 0)] = "Key";
-	ScaleType[(ScaleType["Value"] = 1)] = "Value";
+    ScaleType[ScaleType["Key"] = 0] = "Key";
+    ScaleType[ScaleType["Value"] = 1] = "Value";
 })(ScaleType || (ScaleType = {}));
 export class ScaleModel {
-	constructor(options, canvasModel) {
-		this.options = options;
-		this.canvasModel = canvasModel;
-	}
-	getScaleKey(allowableKeys) {
-		const bandLikeCharts = this.getChartsByTypes(this.options.charts, ["bar", "dot"]);
-		return {
-			domain: allowableKeys,
-			range: {
-				start: 0,
-				end: getScaleKeyRangePeek(this.options.orientation, this.canvasModel)
-			},
-			type: this.getScaleKeyType(this.options.charts),
-			elementsAmount: getElementsAmountForScale(bandLikeCharts)
-		};
-	}
-	getScaleLinear(dataRows, configReader) {
-		var _a;
-		return {
-			domain: getScaleLinearDomain(this.options.axis.value.domain, dataRows, this.options),
-			range: {
-				start: 0,
-				end: getScaleValueRangePeek(this.options.orientation, this.canvasModel)
-			},
-			type: "linear",
-			formatter:
-				(_a =
-					configReader === null || configReader === void 0
-						? void 0
-						: configReader.getAxisLabelFormatter()) !== null && _a !== void 0
-					? _a
-					: null
-		};
-	}
-	getScaleSecondaryLinear(dataRows, configReader) {
-		var _a;
-		return {
-			domain: getScaleLinearDomain(this.options.axis.valueSecondary.domain, dataRows, this.options, "secondary"),
-			range: {
-				start: 0,
-				end: getScaleValueRangePeek(this.options.orientation, this.canvasModel)
-			},
-			type: "linear",
-			formatter:
-				(_a =
-					configReader === null || configReader === void 0
-						? void 0
-						: configReader.getSecondaryAxisLabelFormatter()) !== null && _a !== void 0
-					? _a
-					: null
-		};
-	}
-	getChartsByTypes(charts, types) {
-		return charts.filter((chart) => types.includes(chart.type));
-	}
-	getScaleKeyType(charts) {
-		if (charts.some((chart) => chart.type === "bar" || chart.type === "dot")) return "band";
-		return "point";
-	}
+    constructor(options, canvasModel) {
+        this.options = options;
+        this.canvasModel = canvasModel;
+    }
+    getScaleKey(allowableKeys) {
+        const bandLikeCharts = this.getChartsByTypes(this.options.charts, ["bar", "dot"]);
+        return {
+            domain: allowableKeys,
+            range: {
+                start: 0,
+                end: getScaleKeyRangePeek(this.options.orientation, this.canvasModel)
+            },
+            type: this.getScaleKeyType(this.options.charts),
+            elementsAmount: getElementsAmountForScale(bandLikeCharts)
+        };
+    }
+    getScaleLinear(dataRows, configReader) {
+        var _a;
+        return {
+            domain: getScaleLinearDomain(this.options.axis.value.domain, dataRows, this.options),
+            range: {
+                start: 0,
+                end: getScaleValueRangePeek(this.options.orientation, this.canvasModel)
+            },
+            type: "linear",
+            formatter: (_a = configReader === null || configReader === void 0 ? void 0 : configReader.getAxisLabelFormatter()) !== null && _a !== void 0 ? _a : null
+        };
+    }
+    getScaleSecondaryLinear(dataRows, configReader) {
+        var _a;
+        return {
+            domain: getScaleLinearDomain(this.options.axis.valueSecondary.domain, dataRows, this.options, "secondary"),
+            range: {
+                start: 0,
+                end: getScaleValueRangePeek(this.options.orientation, this.canvasModel)
+            },
+            type: "linear",
+            formatter: (_a = configReader === null || configReader === void 0 ? void 0 : configReader.getSecondaryAxisLabelFormatter()) !== null && _a !== void 0 ? _a : null
+        };
+    }
+    getChartsByTypes(charts, types) {
+        return charts.filter((chart) => types.includes(chart.type));
+    }
+    getScaleKeyType(charts) {
+        if (charts.some((chart) => chart.type === "bar" || chart.type === "dot"))
+            return "band";
+        return "point";
+    }
 }

package/lib/model/featuresModel/scaleModel/scaleModelServices.js

@@ -1,21 +1,28 @@
 export function getScaleKeyRangePeek(chartOrientation, canvasModel) {
-	if (chartOrientation === "vertical") return canvasModel.getChartBlockWidth();
-	return canvasModel.getChartBlockHeight();
+    if (chartOrientation === "vertical")
+        return canvasModel.getChartBlockWidth();
+    return canvasModel.getChartBlockHeight();
 }
 export function getScaleValueRangePeek(chartOrientation, canvasModel) {
-	if (chartOrientation === "vertical") return canvasModel.getChartBlockHeight();
-	return canvasModel.getChartBlockWidth();
+    if (chartOrientation === "vertical")
+        return canvasModel.getChartBlockHeight();
+    return canvasModel.getChartBlockWidth();
 }
 export function getElementsAmountForScale(bandLikeCharts) {
-	if (bandLikeCharts.length === 0) return 1;
-	let barAmounts = {};
-	bandLikeCharts.forEach((chart) => {
-		if (!barAmounts[chart.type]) barAmounts[chart.type] = 0;
-		if (chart.type === "dot") barAmounts[chart.type] = 1;
-		if (chart.type === "bar") {
-			if (chart.isSegmented) barAmounts[chart.type] += 1;
-			else barAmounts[chart.type] += chart.data.valueFields.length;
-		}
-	});
-	return Math.max(...Object.values(barAmounts));
+    if (bandLikeCharts.length === 0)
+        return 1;
+    let barAmounts = {};
+    bandLikeCharts.forEach((chart) => {
+        if (!barAmounts[chart.type])
+            barAmounts[chart.type] = 0;
+        if (chart.type === "dot")
+            barAmounts[chart.type] = 1;
+        if (chart.type === "bar") {
+            if (chart.isSegmented)
+                barAmounts[chart.type] += 1;
+            else
+                barAmounts[chart.type] += chart.data.valueFields.length;
+        }
+    });
+    return Math.max(...Object.values(barAmounts));
 }

package/lib/model/featuresModel/titleModel.d.ts

@@ -1,5 +1,5 @@
 import { TitleBlockModel } from "../model";
 import { TitleConfigReader } from "../modelInstance/titleConfigReader";
 export declare class TitleModel {
-	static getTitleModel(titleConfig: TitleConfigReader): TitleBlockModel;
+    static getTitleModel(titleConfig: TitleConfigReader): TitleBlockModel;
 }

package/lib/model/featuresModel/titleModel.js

@@ -1,16 +1,16 @@
 export class TitleModel {
-	static getTitleModel(titleConfig) {
-		const defaultPads = titleConfig.getFontSize();
-		const pad = titleConfig.getTextContent() ? defaultPads : 0;
-		return {
-			margin: {
-				bottom: 5,
-				left: 0,
-				right: 0,
-				top: 0
-			},
-			size: pad,
-			pad: 0
-		};
-	}
+    static getTitleModel(titleConfig) {
+        const defaultPads = titleConfig.getFontSize();
+        const pad = titleConfig.getTextContent() ? defaultPads : 0;
+        return {
+            margin: {
+                bottom: 5,
+                left: 0,
+                right: 0,
+                top: 0
+            },
+            size: pad,
+            pad: 0
+        };
+    }
 }

package/lib/model/featuresModel/tooltipModel.d.ts

@@ -1,4 +1,4 @@
 import { TooltipSettings } from "../../designer/designerConfig";
 export declare class TooltipModel {
-	static getTooltipModel(options: TooltipSettings): TooltipSettings;
+    static getTooltipModel(options: TooltipSettings): TooltipSettings;
 }

package/lib/model/featuresModel/tooltipModel.js

@@ -1,7 +1,7 @@
 export class TooltipModel {
-	static getTooltipModel(options) {
-		return {
-			position: (options === null || options === void 0 ? void 0 : options.position) || "followCursor"
-		};
-	}
+    static getTooltipModel(options) {
+        return {
+            position: (options === null || options === void 0 ? void 0 : options.position) || "followCursor"
+        };
+    }
 }

package/lib/model/featuresModel/valueLabelsModel/valueLabelsModel.d.ts

@@ -2,36 +2,24 @@ import { BlockMargin, Orient, ValueLabelAnchor, ValueLabelDominantBaseline } fro
 import { BoundingRect } from "../../../engine/features/valueLabelsCollision/valueLabelsCollision";
 import { Size, ValueLabelsPositionMode, ValueLabelsRotationOptions } from "../../../config/config";
 interface ValueLabelAlignment {
-	dominantBaseline: ValueLabelDominantBaseline;
-	textAnchor: ValueLabelAnchor;
+    dominantBaseline: ValueLabelDominantBaseline;
+    textAnchor: ValueLabelAnchor;
 }
 export declare const OFFSET_SIZE_PX = 10;
 export declare const BORDER_OFFSET_SIZE_PX = 2;
 export declare class ValueLabelCoordinateCalculator {
-	private readonly keyAxisOrient;
-	private readonly margin;
-	private readonly offsetSizePx;
-	constructor(positionMode: ValueLabelsPositionMode | undefined, keyAxisOrient: Orient, margin: BlockMargin);
-	getValueLabelY(scaledValue: number): number;
-	getValueLabelX(scaledValue: number): number;
+    private readonly keyAxisOrient;
+    private readonly margin;
+    private readonly offsetSizePx;
+    constructor(positionMode: ValueLabelsPositionMode | undefined, keyAxisOrient: Orient, margin: BlockMargin);
+    getValueLabelY(scaledValue: number): number;
+    getValueLabelX(scaledValue: number): number;
 }
-export declare function calculateValueLabelAlignment(
-	keyAxisOrient: Orient,
-	positionMode?: ValueLabelsPositionMode,
-	rotation?: ValueLabelsRotationOptions
-): ValueLabelAlignment;
+export declare function calculateValueLabelAlignment(keyAxisOrient: Orient, positionMode?: ValueLabelsPositionMode, rotation?: ValueLabelsRotationOptions): ValueLabelAlignment;
 export declare function hasCollisionLeftSide(labelClientRect: BoundingRect, margin: BlockMargin): boolean;
-export declare function hasCollisionRightSide(
-	labelClientRect: BoundingRect,
-	blockSize: Size,
-	margin: BlockMargin
-): boolean;
+export declare function hasCollisionRightSide(labelClientRect: BoundingRect, blockSize: Size, margin: BlockMargin): boolean;
 export declare function hasCollisionTopSide(labelClientRect: BoundingRect, margin: BlockMargin): boolean;
-export declare function hasCollisionBottomSide(
-	labelClientRect: BoundingRect,
-	blockSize: Size,
-	margin: BlockMargin
-): boolean;
+export declare function hasCollisionBottomSide(labelClientRect: BoundingRect, blockSize: Size, margin: BlockMargin): boolean;
 export declare function shiftCoordinateXLeft(labelClientRect: BoundingRect, blockSize: Size, margin: BlockMargin): void;
 export declare function shiftCoordinateXRight(labelClientRect: BoundingRect, margin: BlockMargin): void;
 export declare function shiftCoordinateYTop(labelClientRect: BoundingRect): void;

package/lib/model/featuresModel/valueLabelsModel/valueLabelsModel.js

@@ -1,75 +1,73 @@
 export const OFFSET_SIZE_PX = 10;
 export const BORDER_OFFSET_SIZE_PX = 2;
 export class ValueLabelCoordinateCalculator {
-	constructor(positionMode, keyAxisOrient, margin) {
-		this.keyAxisOrient = keyAxisOrient;
-		this.margin = margin;
-		this.offsetSizePx = positionMode === "center" ? 0 : OFFSET_SIZE_PX;
-	}
-	getValueLabelY(scaledValue) {
-		switch (this.keyAxisOrient) {
-			case "bottom":
-				return scaledValue - this.offsetSizePx + this.margin.top;
-			case "top":
-				return scaledValue + this.offsetSizePx + this.margin.top;
-			default:
-				return scaledValue + this.margin.top;
-		}
-	}
-	getValueLabelX(scaledValue) {
-		switch (this.keyAxisOrient) {
-			case "right":
-				return scaledValue - this.offsetSizePx + this.margin.left;
-			case "left":
-				return scaledValue + this.offsetSizePx + this.margin.left;
-			default:
-				return scaledValue + this.margin.left;
-		}
-	}
+    constructor(positionMode, keyAxisOrient, margin) {
+        this.keyAxisOrient = keyAxisOrient;
+        this.margin = margin;
+        this.offsetSizePx = positionMode === "center" ? 0 : OFFSET_SIZE_PX;
+    }
+    getValueLabelY(scaledValue) {
+        switch (this.keyAxisOrient) {
+            case "bottom":
+                return scaledValue - this.offsetSizePx + this.margin.top;
+            case "top":
+                return scaledValue + this.offsetSizePx + this.margin.top;
+            default:
+                return scaledValue + this.margin.top;
+        }
+    }
+    getValueLabelX(scaledValue) {
+        switch (this.keyAxisOrient) {
+            case "right":
+                return scaledValue - this.offsetSizePx + this.margin.left;
+            case "left":
+                return scaledValue + this.offsetSizePx + this.margin.left;
+            default:
+                return scaledValue + this.margin.left;
+        }
+    }
 }
 export function calculateValueLabelAlignment(keyAxisOrient, positionMode, rotation) {
-	if (
-		(positionMode !== null && positionMode !== void 0 ? positionMode : "after") === "after" &&
-		!(rotation === null || rotation === void 0 ? void 0 : rotation.angle)
-	) {
-		switch (keyAxisOrient) {
-			case "top":
-				return { dominantBaseline: "hanging", textAnchor: "middle" };
-			case "bottom":
-				return { dominantBaseline: "auto", textAnchor: "middle" };
-			case "left":
-				return { dominantBaseline: "middle", textAnchor: "start" };
-			case "right":
-				return { dominantBaseline: "middle", textAnchor: "end" };
-		}
-	} else {
-		return { dominantBaseline: "middle", textAnchor: "middle" };
-	}
+    if ((positionMode !== null && positionMode !== void 0 ? positionMode : "after") === "after" && !(rotation === null || rotation === void 0 ? void 0 : rotation.angle)) {
+        switch (keyAxisOrient) {
+            case "top":
+                return { dominantBaseline: "hanging", textAnchor: "middle" };
+            case "bottom":
+                return { dominantBaseline: "auto", textAnchor: "middle" };
+            case "left":
+                return { dominantBaseline: "middle", textAnchor: "start" };
+            case "right":
+                return { dominantBaseline: "middle", textAnchor: "end" };
+        }
+    }
+    else {
+        return { dominantBaseline: "middle", textAnchor: "middle" };
+    }
 }
 export function hasCollisionLeftSide(labelClientRect, margin) {
-	return labelClientRect.x - labelClientRect.width / 2 <= margin.left;
+    return labelClientRect.x - labelClientRect.width / 2 <= margin.left;
 }
 export function hasCollisionRightSide(labelClientRect, blockSize, margin) {
-	return labelClientRect.x + labelClientRect.width / 2 >= blockSize.width - margin.right;
+    return labelClientRect.x + labelClientRect.width / 2 >= blockSize.width - margin.right;
 }
 export function hasCollisionTopSide(labelClientRect, margin) {
-	return labelClientRect.y - labelClientRect.height / 2 <= margin.top;
+    return labelClientRect.y - labelClientRect.height / 2 <= margin.top;
 }
 export function hasCollisionBottomSide(labelClientRect, blockSize, margin) {
-	return labelClientRect.y + labelClientRect.height / 2 >= blockSize.height - margin.bottom;
+    return labelClientRect.y + labelClientRect.height / 2 >= blockSize.height - margin.bottom;
 }
 export function shiftCoordinateXLeft(labelClientRect, blockSize, margin) {
-	const blockRightSide = blockSize.width - margin.right;
-	const labelRightSide = labelClientRect.x + labelClientRect.width / 2;
-	labelClientRect.x -= labelRightSide - blockRightSide + BORDER_OFFSET_SIZE_PX;
+    const blockRightSide = blockSize.width - margin.right;
+    const labelRightSide = labelClientRect.x + labelClientRect.width / 2;
+    labelClientRect.x -= labelRightSide - blockRightSide + BORDER_OFFSET_SIZE_PX;
 }
 export function shiftCoordinateXRight(labelClientRect, margin) {
-	const labelLeftSide = labelClientRect.x - labelClientRect.width / 2;
-	labelClientRect.x += margin.left - labelLeftSide + BORDER_OFFSET_SIZE_PX;
+    const labelLeftSide = labelClientRect.x - labelClientRect.width / 2;
+    labelClientRect.x += margin.left - labelLeftSide + BORDER_OFFSET_SIZE_PX;
 }
 export function shiftCoordinateYTop(labelClientRect) {
-	labelClientRect.y -= labelClientRect.height / 2 + BORDER_OFFSET_SIZE_PX;
+    labelClientRect.y -= labelClientRect.height / 2 + BORDER_OFFSET_SIZE_PX;
 }
 export function shiftCoordinateYBottom(labelClientRect) {
-	labelClientRect.y += labelClientRect.height / 2 + BORDER_OFFSET_SIZE_PX;
+    labelClientRect.y += labelClientRect.height / 2 + BORDER_OFFSET_SIZE_PX;
 }

package/lib/model/helpers/modelHelper.d.ts

@@ -1,9 +1,9 @@
 export declare class ModelHelper {
-	private static readonly defaultBaseFontSize;
-	private static baseFontSize;
-	private static getBaseFontSize;
-	static getFontSizeCssValue(propertyName: string, defaultValue: number): number;
-	static getSum(items: number[]): number;
-	static getUniqueValues(values: string[]): string[];
-	static getStringScore(word: string): number;
+    private static readonly defaultBaseFontSize;
+    private static baseFontSize;
+    private static getBaseFontSize;
+    static getFontSizeCssValue(propertyName: string, defaultValue: number): number;
+    static getSum(items: number[]): number;
+    static getUniqueValues(values: string[]): string[];
+    static getStringScore(word: string): number;
 }

package/lib/model/helpers/modelHelper.js

@@ -1,42 +1,46 @@
 import { DomHelper } from "../../engine/helpers/domHelper";
 export class ModelHelper {
-	static getBaseFontSize(propertyName) {
-		if (!this.baseFontSize) this.baseFontSize = this.getFontSizeCssValue(propertyName, this.defaultBaseFontSize);
-		return this.baseFontSize;
-	}
-	static getFontSizeCssValue(propertyName, defaultValue) {
-		const value = parseInt(DomHelper.getCssPropertyValue(document.documentElement, propertyName));
-		return isNaN(value) ? defaultValue : value;
-	}
-	static getSum(items) {
-		return items.reduce((acc, item) => acc + item, 0);
-	}
-	static getUniqueValues(values) {
-		const uniqueValues = values.filter((keyValue, index, self) => self.indexOf(keyValue) === index);
-		return uniqueValues;
-	}
-	static getStringScore(word) {
-		// lower case letter width ~ 0.8 from upper case width.
-		// Number width == lower case letter width
-		const fontSize = this.getBaseFontSize("--chart-base-font-size");
-		let score = 0;
-		const upperLetterScore = fontSize / 9;
-		const lowerLetterScore = fontSize / 13;
-		const digitScore = fontSize / 15;
-		const otherSymbolScore = fontSize / 23;
-		const specialSmallSymbols = [",", ".", " "];
-		for (let i = 0; i < word.length; i++) {
-			if (
-				parseFloat(word[i]).toString() !== word[i] &&
-				!specialSmallSymbols.includes(word[i]) &&
-				word[i].trim().length > 0
-			) {
-				if (word[i].toUpperCase() === word[i]) score += upperLetterScore;
-				else score += lowerLetterScore;
-			} else if (word[i] == parseInt(word[i]).toString()) score += digitScore;
-			else score += otherSymbolScore;
-		}
-		return score;
-	}
+    static getBaseFontSize(propertyName) {
+        if (!this.baseFontSize)
+            this.baseFontSize = this.getFontSizeCssValue(propertyName, this.defaultBaseFontSize);
+        return this.baseFontSize;
+    }
+    static getFontSizeCssValue(propertyName, defaultValue) {
+        const value = parseInt(DomHelper.getCssPropertyValue(document.documentElement, propertyName));
+        return isNaN(value) ? defaultValue : value;
+    }
+    static getSum(items) {
+        return items.reduce((acc, item) => acc + item, 0);
+    }
+    static getUniqueValues(values) {
+        const uniqueValues = values.filter((keyValue, index, self) => self.indexOf(keyValue) === index);
+        return uniqueValues;
+    }
+    static getStringScore(word) {
+        // lower case letter width ~ 0.8 from upper case width.
+        // Number width == lower case letter width
+        const fontSize = this.getBaseFontSize("--chart-base-font-size");
+        let score = 0;
+        const upperLetterScore = fontSize / 9;
+        const lowerLetterScore = fontSize / 13;
+        const digitScore = fontSize / 15;
+        const otherSymbolScore = fontSize / 23;
+        const specialSmallSymbols = [",", ".", " "];
+        for (let i = 0; i < word.length; i++) {
+            if (parseFloat(word[i]).toString() !== word[i] &&
+                !specialSmallSymbols.includes(word[i]) &&
+                word[i].trim().length > 0) {
+                if (word[i].toUpperCase() === word[i])
+                    score += upperLetterScore;
+                else
+                    score += lowerLetterScore;
+            }
+            else if (word[i] == parseInt(word[i]).toString())
+                score += digitScore;
+            else
+                score += otherSymbolScore;
+        }
+        return score;
+    }
 }
 ModelHelper.defaultBaseFontSize = 13;