mdt-charts 1.28.1 → 1.29.0

package/lib/engine/features/legend/legendWidthCalculator.js

@@ -1,134 +1,138 @@
 export function getNewLegendItemWidths(config) {
-    const wrapper = new LegendWrapper(config.wrapper);
-    const collection = new LegendItemCollection(config.items.map((i) => new LegendItem(i)));
-    return getNewWidths(collection, wrapper);
+	const wrapper = new LegendWrapper(config.wrapper);
+	const collection = new LegendItemCollection(config.items.map((i) => new LegendItem(i)));
+	return getNewWidths(collection, wrapper);
 }
 function getNewWidths(collection, wrapper) {
-    let extra = collection.getTotalWidth() - wrapper.getMaxWidth();
-    if (extra <= 0) {
-        return fixWidthsByLinePos(collection, wrapper);
-    }
-    const avgWidth = (wrapper.getMaxWidth() - collection.getTotalMarginSizes()) / collection.getItemsAmount();
-    const biggerThanAvg = collection.getItemsWithWidthBiggerThan(avgWidth);
-    let avgExtra = extra / biggerThanAvg.length;
-    biggerThanAvg.forEach((item, index) => {
-        const avgDiff = item.getCurrentWidth() - avgWidth;
-        const decreaseBy = index === biggerThanAvg.length - 1 ? extra : avgDiff < avgExtra ? avgDiff : avgExtra;
-        item.decreaseBy(decreaseBy);
-        extra -= decreaseBy;
-        avgExtra = extra / (biggerThanAvg.length - index - 1);
-    });
-    return fixWidthsByLinePos(collection, wrapper);
+	let extra = collection.getTotalWidth() - wrapper.getMaxWidth();
+	if (extra <= 0) {
+		return fixWidthsByLinePos(collection, wrapper);
+	}
+	const avgWidth = (wrapper.getMaxWidth() - collection.getTotalMarginSizes()) / collection.getItemsAmount();
+	const biggerThanAvg = collection.getItemsWithWidthBiggerThan(avgWidth);
+	let avgExtra = extra / biggerThanAvg.length;
+	biggerThanAvg.forEach((item, index) => {
+		const avgDiff = item.getCurrentWidth() - avgWidth;
+		const decreaseBy = index === biggerThanAvg.length - 1 ? extra : avgDiff < avgExtra ? avgDiff : avgExtra;
+		item.decreaseBy(decreaseBy);
+		extra -= decreaseBy;
+		avgExtra = extra / (biggerThanAvg.length - index - 1);
+	});
+	return fixWidthsByLinePos(collection, wrapper);
 }
 function fixWidthsByLinePos(collection, wrapper) {
-    const byRows = [];
-    let currentRow = [];
-    collection.items.forEach((item, i) => {
-        const currentRowSum = currentRow.reduce((acc, i) => acc + i.getCurrentTotalWidth(), 0);
-        if (currentRowSum + item.getCurrentTotalWidth() <= wrapper.getWidthOfOneLine()) {
-            currentRow.push(item);
-        }
-        else {
-            byRows.push(new LegendItemCollection(currentRow));
-            currentRow = [item];
-        }
-        if (i === collection.items.length - 1)
-            byRows.push(new LegendItemCollection(currentRow));
-    });
-    if (byRows.length <= wrapper.getMaxRowsCount())
-        return collection.getActualWidths();
-    const result = [];
-    for (let i = 0; i < byRows.length - 1; i++) {
-        const top = byRows[i];
-        const bottom = byRows[i + 1];
-        const topFreeSpace = wrapper.getWidthOfOneLine() - top.getTotalWidth();
-        const firstOfBottom = bottom.getFirstItem();
-        if (i === byRows.length - 2)
-            top.pushMany(bottom.shiftAll());
-        else if (topFreeSpace / firstOfBottom.getCurrentTotalWidth() > 0.5) {
-            const fromBottom = bottom.shift();
-            top.push(fromBottom);
-        }
-        result.push(...getNewWidths(top, new LegendWrapper({ maxRowsAmount: 1, width: wrapper.getWidthOfOneLine() })));
-    }
-    return result;
+	const byRows = [];
+	let currentRow = [];
+	collection.items.forEach((item, i) => {
+		const currentRowSum = currentRow.reduce((acc, i) => acc + i.getCurrentTotalWidth(), 0);
+		if (currentRowSum + item.getCurrentTotalWidth() <= wrapper.getWidthOfOneLine()) {
+			currentRow.push(item);
+		} else {
+			byRows.push(new LegendItemCollection(currentRow));
+			currentRow = [item];
+		}
+		if (i === collection.items.length - 1) byRows.push(new LegendItemCollection(currentRow));
+	});
+	if (byRows.length <= wrapper.getMaxRowsCount()) return collection.getActualWidths();
+	const result = [];
+	for (let i = 0; i < byRows.length - 1; i++) {
+		const top = byRows[i];
+		const bottom = byRows[i + 1];
+		const topFreeSpace = wrapper.getWidthOfOneLine() - top.getTotalWidth();
+		const firstOfBottom = bottom.getFirstItem();
+		if (i === byRows.length - 2) top.pushMany(bottom.shiftAll());
+		else if (topFreeSpace / firstOfBottom.getCurrentTotalWidth() > 0.5) {
+			const fromBottom = bottom.shift();
+			top.push(fromBottom);
+		}
+		result.push(
+			...getNewWidths(
+				top,
+				new LegendWrapper({
+					maxRowsAmount: 1,
+					width: wrapper.getWidthOfOneLine()
+				})
+			)
+		);
+	}
+	return result;
 }
 class LegendWrapper {
-    constructor(config) {
-        this.config = config;
-    }
-    getMaxWidth() {
-        return this.config.width * this.config.maxRowsAmount;
-    }
-    getWidthOfOneLine() {
-        return this.config.width;
-    }
-    getMaxRowsCount() {
-        return this.config.maxRowsAmount;
-    }
+	constructor(config) {
+		this.config = config;
+	}
+	getMaxWidth() {
+		return this.config.width * this.config.maxRowsAmount;
+	}
+	getWidthOfOneLine() {
+		return this.config.width;
+	}
+	getMaxRowsCount() {
+		return this.config.maxRowsAmount;
+	}
 }
 class LegendItem {
-    constructor(config) {
-        this.config = config;
-        this.width = this.config.width;
-    }
-    getCurrentTotalWidth() {
-        return this.width + this.getTotalMarginSize();
-    }
-    getWidthWithoutRightMargin() {
-        return this.width + this.config.marginLeft;
-    }
-    decreaseBy(by) {
-        this.width -= by;
-    }
-    getCurrentWidth() {
-        return Math.round(this.width * 100) / 100;
-    }
-    getTotalMarginSize() {
-        return this.config.marginLeft + this.config.marginRight;
-    }
-    resetWidthToOriginal() {
-        this.width = this.config.width;
-    }
+	constructor(config) {
+		this.config = config;
+		this.width = this.config.width;
+	}
+	getCurrentTotalWidth() {
+		return this.width + this.getTotalMarginSize();
+	}
+	getWidthWithoutRightMargin() {
+		return this.width + this.config.marginLeft;
+	}
+	decreaseBy(by) {
+		this.width -= by;
+	}
+	getCurrentWidth() {
+		return Math.round(this.width * 100) / 100;
+	}
+	getTotalMarginSize() {
+		return this.config.marginLeft + this.config.marginRight;
+	}
+	resetWidthToOriginal() {
+		this.width = this.config.width;
+	}
 }
 class LegendItemCollection {
-    constructor(items) {
-        this.items = items;
-    }
-    getTotalWidth() {
-        return this.items.reduce((acc, item) => acc + item.getCurrentTotalWidth(), 0);
-    }
-    getActualWidths() {
-        return this.items.map((item) => item.getCurrentWidth());
-    }
-    getTotalMarginSizes() {
-        return this.items.reduce((acc, item) => acc + item.getTotalMarginSize(), 0);
-    }
-    getItemsAmount() {
-        return this.items.length;
-    }
-    getItemsWithWidthBiggerThan(thanWidth) {
-        return this.items
-            .filter((item) => item.getCurrentWidth() > thanWidth)
-            .sort((a, b) => a.getCurrentWidth() - b.getCurrentWidth());
-    }
-    getFirstItem() {
-        return this.items[0];
-    }
-    shift() {
-        return this.items.shift();
-    }
-    shiftAll() {
-        return this.items.splice(0, this.items.length);
-    }
-    push(item) {
-        this.items.push(item);
-    }
-    pushMany(items) {
-        this.items.push(...items);
-    }
-    resetItemsToOriginalWidth() {
-        this.items.forEach((item) => item.resetWidthToOriginal());
-        return this;
-    }
+	constructor(items) {
+		this.items = items;
+	}
+	getTotalWidth() {
+		return this.items.reduce((acc, item) => acc + item.getCurrentTotalWidth(), 0);
+	}
+	getActualWidths() {
+		return this.items.map((item) => item.getCurrentWidth());
+	}
+	getTotalMarginSizes() {
+		return this.items.reduce((acc, item) => acc + item.getTotalMarginSize(), 0);
+	}
+	getItemsAmount() {
+		return this.items.length;
+	}
+	getItemsWithWidthBiggerThan(thanWidth) {
+		return this.items
+			.filter((item) => item.getCurrentWidth() > thanWidth)
+			.sort((a, b) => a.getCurrentWidth() - b.getCurrentWidth());
+	}
+	getFirstItem() {
+		return this.items[0];
+	}
+	shift() {
+		return this.items.shift();
+	}
+	shiftAll() {
+		return this.items.splice(0, this.items.length);
+	}
+	push(item) {
+		this.items.push(item);
+	}
+	pushMany(items) {
+		this.items.push(...items);
+	}
+	resetItemsToOriginalWidth() {
+		this.items.forEach((item) => item.resetWidthToOriginal());
+		return this;
+	}
 }

package/lib/engine/features/markDots/markDot.d.ts

@@ -4,24 +4,51 @@ import { BlockMargin, MarkersOptions, Orient, TwoDimensionalChartModel } from ".
 import { Block } from "../../block/block";
 import { Scales } from "../scale/scale";
 export interface DotAttrs {
-    cx: (data: MdtChartsDataRow) => number;
-    cy: (data: MdtChartsDataRow) => number;
+	cx: (data: MdtChartsDataRow) => number;
+	cy: (data: MdtChartsDataRow) => number;
 }
 interface MarkDotDataItem extends MdtChartsDataRow {
-    $mdtChartsMetadata: {
-        valueFieldName: string;
-    };
+	$mdtChartsMetadata: {
+		valueFieldName: string;
+	};
 }
 export declare class MarkDot {
-    static readonly markerDotClass: string;
-    static readonly hiddenDotClass: string;
-    static render(block: Block, data: MdtChartsDataRow[], keyAxisOrient: Orient, scales: Scales, margin: BlockMargin, keyFieldName: string, vfIndex: number, valueFieldName: string, chart: TwoDimensionalChartModel): void;
-    static update(block: Block, newData: MdtChartsDataRow[], keyAxisOrient: Orient, scales: Scales, margin: BlockMargin, keyFieldName: string, vfIndex: number, valueFieldName: string, chart: TwoDimensionalChartModel): void;
-    static updateColors(block: Block, chart: TwoDimensionalChartModel, valueFieldIndex: number): void;
-    static getMarkDotForChart(block: Block, chartCssClasses: string[]): Selection<BaseType, MarkDotDataItem, BaseType, unknown>;
-    static tryMakeMarkDotVisible(elems: Selection<BaseType, MdtChartsDataRow, BaseType, unknown>, markersOptions: MarkersOptions, turnOnIfCan: boolean): void;
-    private static toggleMarkDotVisible;
-    private static setClassesAndStyle;
-    private static setAttrs;
+	static readonly markerDotClass: string;
+	static readonly hiddenDotClass: string;
+	static render(
+		block: Block,
+		data: MdtChartsDataRow[],
+		keyAxisOrient: Orient,
+		scales: Scales,
+		margin: BlockMargin,
+		keyFieldName: string,
+		vfIndex: number,
+		valueFieldName: string,
+		chart: TwoDimensionalChartModel
+	): void;
+	static update(
+		block: Block,
+		newData: MdtChartsDataRow[],
+		keyAxisOrient: Orient,
+		scales: Scales,
+		margin: BlockMargin,
+		keyFieldName: string,
+		vfIndex: number,
+		valueFieldName: string,
+		chart: TwoDimensionalChartModel
+	): void;
+	static updateColors(block: Block, chart: TwoDimensionalChartModel, valueFieldIndex: number): void;
+	static getMarkDotForChart(
+		block: Block,
+		chartCssClasses: string[]
+	): Selection<BaseType, MarkDotDataItem, BaseType, unknown>;
+	static tryMakeMarkDotVisible(
+		elems: Selection<BaseType, MdtChartsDataRow, BaseType, unknown>,
+		markersOptions: MarkersOptions,
+		turnOnIfCan: boolean
+	): void;
+	private static toggleMarkDotVisible;
+	private static setClassesAndStyle;
+	private static setAttrs;
 }
 export {};

package/lib/engine/features/markDots/markDot.js

@@ -6,76 +6,107 @@ import { NamesHelper } from "../../helpers/namesHelper";
 import { MarkDotHelper } from "./markDotsHelper";
 select.prototype.transition = transition;
 export class MarkDot {
-    static render(block, data, keyAxisOrient, scales, margin, keyFieldName, vfIndex, valueFieldName, chart) {
-        const dotsWrapper = block.svg
-            .getChartGroup(chart.index)
-            .selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-index-${vfIndex}`)
-            .data(data.map((row) => (Object.assign(Object.assign({}, row), { $mdtChartsMetadata: { valueFieldName } }))))
-            .enter();
-        const attrs = MarkDotHelper.getDotAttrs(keyAxisOrient, scales, margin, keyFieldName, valueFieldName, chart.isSegmented);
-        const dots = dotsWrapper.append("circle");
-        this.setAttrs(block, dots, attrs, chart.markersOptions.styles);
-        this.setClassesAndStyle(dots, chart.cssClasses, vfIndex, chart.style.elementColors);
-        MarkDot.tryMakeMarkDotVisible(dots, chart.markersOptions, false);
-    }
-    static update(block, newData, keyAxisOrient, scales, margin, keyFieldName, vfIndex, valueFieldName, chart) {
-        const dots = block.svg
-            .getChartGroup(chart.index)
-            .selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${vfIndex}`)
-            .data(newData.map((row) => (Object.assign(Object.assign({}, row), { $mdtChartsMetadata: { valueFieldName } }))));
-        dots.exit().remove();
-        dots.each(function (datum) {
-            if (chart.markersOptions.show({ row: datum, valueFieldName })) {
-                MarkDot.toggleMarkDotVisible(select(this), true);
-            }
-        });
-        const attrs = MarkDotHelper.getDotAttrs(keyAxisOrient, scales, margin, keyFieldName, valueFieldName, chart.isSegmented);
-        const newDots = dots.enter().append("circle");
-        this.setAttrs(block, newDots, attrs, chart.markersOptions.styles);
-        this.setClassesAndStyle(newDots, chart.cssClasses, vfIndex, chart.style.elementColors);
-        MarkDot.tryMakeMarkDotVisible(newDots, chart.markersOptions, false);
-        const animationName = "data-updating";
-        dots.interrupt(animationName)
-            .transition(animationName)
-            .duration(block.transitionManager.durations.chartUpdate)
-            .attr("cx", (d) => attrs.cx(d))
-            .attr("cy", (d) => attrs.cy(d));
-    }
-    static updateColors(block, chart, valueFieldIndex) {
-        const dots = block.svg
-            .getChartGroup(chart.index)
-            .selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${valueFieldIndex}`);
-        DomHelper.setChartElementColor(dots, chart.style.elementColors, valueFieldIndex, "stroke");
-    }
-    static getMarkDotForChart(block, chartCssClasses) {
-        return block.getSvg().selectAll(`.${MarkDot.markerDotClass}${Helper.getCssClassesLine(chartCssClasses)}`);
-    }
-    static tryMakeMarkDotVisible(elems, markersOptions, turnOnIfCan) {
-        elems.each(function (datum) {
-            var _a;
-            if (!markersOptions.show({
-                row: datum,
-                valueFieldName: (_a = datum.$mdtChartsMetadata) === null || _a === void 0 ? void 0 : _a.valueFieldName
-            }))
-                MarkDot.toggleMarkDotVisible(select(this), turnOnIfCan);
-        });
-    }
-    static toggleMarkDotVisible(markDots, isHighlight) {
-        markDots.classed(MarkDot.hiddenDotClass, !isHighlight);
-    }
-    static setClassesAndStyle(dots, cssClasses, vfIndex, elementColors) {
-        DomHelper.setCssClasses(dots, Helper.getCssClassesWithElementIndex(cssClasses, vfIndex));
-        DomHelper.setChartElementColor(dots, elementColors, vfIndex, "stroke");
-    }
-    static setAttrs(block, dots, attrs, styles) {
-        dots.attr("class", this.markerDotClass)
-            .attr("cx", (d) => attrs.cx(d))
-            .attr("cy", (d) => attrs.cy(d))
-            .attr("r", styles.normal.size.radius)
-            .style("stroke-width", styles.normal.size.borderSize)
-            .style("fill", "white")
-            .style("clip-path", `url(#${block.svg.getClipPathId()})`);
-    }
+	static render(block, data, keyAxisOrient, scales, margin, keyFieldName, vfIndex, valueFieldName, chart) {
+		const dotsWrapper = block.svg
+			.getChartGroup(chart.index)
+			.selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-index-${vfIndex}`)
+			.data(
+				data.map((row) =>
+					Object.assign(Object.assign({}, row), {
+						$mdtChartsMetadata: { valueFieldName }
+					})
+				)
+			)
+			.enter();
+		const attrs = MarkDotHelper.getDotAttrs(
+			keyAxisOrient,
+			scales,
+			margin,
+			keyFieldName,
+			valueFieldName,
+			chart.isSegmented
+		);
+		const dots = dotsWrapper.append("circle");
+		this.setAttrs(block, dots, attrs, chart.markersOptions.styles);
+		this.setClassesAndStyle(dots, chart.cssClasses, vfIndex, chart.style.elementColors);
+		MarkDot.tryMakeMarkDotVisible(dots, chart.markersOptions, false);
+	}
+	static update(block, newData, keyAxisOrient, scales, margin, keyFieldName, vfIndex, valueFieldName, chart) {
+		const dots = block.svg
+			.getChartGroup(chart.index)
+			.selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${vfIndex}`)
+			.data(
+				newData.map((row) =>
+					Object.assign(Object.assign({}, row), {
+						$mdtChartsMetadata: { valueFieldName }
+					})
+				)
+			);
+		dots.exit().remove();
+		dots.each(function (datum) {
+			if (chart.markersOptions.show({ row: datum, valueFieldName })) {
+				MarkDot.toggleMarkDotVisible(select(this), true);
+			}
+		});
+		const attrs = MarkDotHelper.getDotAttrs(
+			keyAxisOrient,
+			scales,
+			margin,
+			keyFieldName,
+			valueFieldName,
+			chart.isSegmented
+		);
+		const newDots = dots.enter().append("circle");
+		this.setAttrs(block, newDots, attrs, chart.markersOptions.styles);
+		this.setClassesAndStyle(newDots, chart.cssClasses, vfIndex, chart.style.elementColors);
+		MarkDot.tryMakeMarkDotVisible(newDots, chart.markersOptions, false);
+		const animationName = "data-updating";
+		dots.interrupt(animationName)
+			.transition(animationName)
+			.duration(block.transitionManager.durations.chartUpdate)
+			.attr("cx", (d) => attrs.cx(d))
+			.attr("cy", (d) => attrs.cy(d));
+	}
+	static updateColors(block, chart, valueFieldIndex) {
+		const dots = block.svg
+			.getChartGroup(chart.index)
+			.selectAll(
+				`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${valueFieldIndex}`
+			);
+		DomHelper.setChartElementColor(dots, chart.style.elementColors, valueFieldIndex, "stroke");
+	}
+	static getMarkDotForChart(block, chartCssClasses) {
+		return block.getSvg().selectAll(`.${MarkDot.markerDotClass}${Helper.getCssClassesLine(chartCssClasses)}`);
+	}
+	static tryMakeMarkDotVisible(elems, markersOptions, turnOnIfCan) {
+		elems.each(function (datum) {
+			var _a;
+			if (
+				!markersOptions.show({
+					row: datum,
+					valueFieldName:
+						(_a = datum.$mdtChartsMetadata) === null || _a === void 0 ? void 0 : _a.valueFieldName
+				})
+			)
+				MarkDot.toggleMarkDotVisible(select(this), turnOnIfCan);
+		});
+	}
+	static toggleMarkDotVisible(markDots, isHighlight) {
+		markDots.classed(MarkDot.hiddenDotClass, !isHighlight);
+	}
+	static setClassesAndStyle(dots, cssClasses, vfIndex, elementColors) {
+		DomHelper.setCssClasses(dots, Helper.getCssClassesWithElementIndex(cssClasses, vfIndex));
+		DomHelper.setChartElementColor(dots, elementColors, vfIndex, "stroke");
+	}
+	static setAttrs(block, dots, attrs, styles) {
+		dots.attr("class", this.markerDotClass)
+			.attr("cx", (d) => attrs.cx(d))
+			.attr("cy", (d) => attrs.cy(d))
+			.attr("r", styles.normal.size.radius)
+			.style("stroke-width", styles.normal.size.borderSize)
+			.style("fill", "white")
+			.style("clip-path", `url(#${block.svg.getClipPathId()})`);
+	}
 }
 MarkDot.markerDotClass = NamesHelper.getClassName("dot");
 MarkDot.hiddenDotClass = NamesHelper.getClassName("dot-hidden");

package/lib/engine/features/markDots/markDotsHelper.d.ts

@@ -2,5 +2,12 @@ import { BlockMargin, Orient } from "../../../model/model";
 import { Scales } from "../scale/scale";
 import { DotAttrs } from "./markDot";
 export declare class MarkDotHelper {
-    static getDotAttrs(keyAxisOrient: Orient, scales: Scales, margin: BlockMargin, keyField: string, valueField: string, isSegmented: boolean): DotAttrs;
+	static getDotAttrs(
+		keyAxisOrient: Orient,
+		scales: Scales,
+		margin: BlockMargin,
+		keyField: string,
+		valueField: string,
+		isSegmented: boolean
+	): DotAttrs;
 }

package/lib/engine/features/markDots/markDotsHelper.js

@@ -1,16 +1,17 @@
 import { Helper } from "../../helpers/helper";
 import { Scale } from "../scale/scale";
 export class MarkDotHelper {
-    static getDotAttrs(keyAxisOrient, scales, margin, keyField, valueField, isSegmented) {
-        const attrs = { cx: null, cy: null };
-        if (keyAxisOrient === "left" || keyAxisOrient === "right") {
-            attrs.cx = (d) => scales.value(d[valueField]) + margin.left;
-            attrs.cy = (d) => Scale.getScaledValue(scales.key, Helper.getKeyFieldValue(d, keyField, isSegmented)) + margin.top;
-        }
-        else if (keyAxisOrient === "bottom" || keyAxisOrient === "top") {
-            attrs.cx = (d) => Scale.getScaledValue(scales.key, Helper.getKeyFieldValue(d, keyField, isSegmented)) + margin.left;
-            attrs.cy = (d) => scales.value(d[valueField]) + margin.top;
-        }
-        return attrs;
-    }
+	static getDotAttrs(keyAxisOrient, scales, margin, keyField, valueField, isSegmented) {
+		const attrs = { cx: null, cy: null };
+		if (keyAxisOrient === "left" || keyAxisOrient === "right") {
+			attrs.cx = (d) => scales.value(d[valueField]) + margin.left;
+			attrs.cy = (d) =>
+				Scale.getScaledValue(scales.key, Helper.getKeyFieldValue(d, keyField, isSegmented)) + margin.top;
+		} else if (keyAxisOrient === "bottom" || keyAxisOrient === "top") {
+			attrs.cx = (d) =>
+				Scale.getScaledValue(scales.key, Helper.getKeyFieldValue(d, keyField, isSegmented)) + margin.left;
+			attrs.cy = (d) => scales.value(d[valueField]) + margin.top;
+		}
+		return attrs;
+	}
 }

package/lib/engine/features/recordOverflowAlert/recordOverflowAlertCore.d.ts

@@ -1,28 +1,28 @@
 import { Block } from "../../block/block";
 export interface RecordOverflowAlertOptions {
-    hidedRecordsAmount: number;
-    text: RecordOverflowAlertText;
-    positionAttrs: AlertBlockPositionAttrs;
+	hidedRecordsAmount: number;
+	text: RecordOverflowAlertText;
+	positionAttrs: AlertBlockPositionAttrs;
 }
 export interface RecordOverflowAlertText {
-    one: string;
-    twoToFour: string;
-    tenToTwenty: string;
-    other: string;
+	one: string;
+	twoToFour: string;
+	tenToTwenty: string;
+	other: string;
 }
 export interface AlertBlockPositionAttrs {
-    top?: string;
-    bottom?: string;
-    right?: string;
-    left?: string;
+	top?: string;
+	bottom?: string;
+	right?: string;
+	left?: string;
 }
 declare class RecordOverflowAlertCoreClass {
-    private readonly blockClass;
-    render(block: Block, options: RecordOverflowAlertOptions): void;
-    update(block: Block, options: RecordOverflowAlertOptions): void;
-    private getAlertText;
-    private getWordTextEndingByAmount;
-    private setAlertPosition;
+	private readonly blockClass;
+	render(block: Block, options: RecordOverflowAlertOptions): void;
+	update(block: Block, options: RecordOverflowAlertOptions): void;
+	private getAlertText;
+	private getWordTextEndingByAmount;
+	private setAlertPosition;
 }
 export declare const RecordOverflowAlertCore: RecordOverflowAlertCoreClass;
 export {};