mdt-charts 1.28.1 → 1.29.0

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

@@ -1,61 +1,50 @@
 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,56 +2,67 @@ 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,28 +1,21 @@
 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,24 +2,36 @@ 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,73 +1,75 @@
 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,46 +1,42 @@
 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;