mdt-charts 1.29.0 → 1.29.1

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

@@ -1,138 +1,134 @@
 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,51 +4,24 @@ 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,107 +6,76 @@ 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,12 +2,5 @@ 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,17 +1,16 @@
 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,10 @@
+import { RecordOverflowAlertModel } from "../../../model/model";
 import { Block } from "../../block/block";
-export interface RecordOverflowAlertOptions {
-	hidedRecordsAmount: number;
-	text: RecordOverflowAlertText;
-	positionAttrs: AlertBlockPositionAttrs;
-}
-export interface RecordOverflowAlertText {
-	one: string;
-	twoToFour: string;
-	tenToTwenty: string;
-	other: string;
-}
-export interface AlertBlockPositionAttrs {
-	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: RecordOverflowAlertModel): void;
+    update(block: Block, options: RecordOverflowAlertModel): void;
+    private setAlertPosition;
 }
 export declare const RecordOverflowAlertCore: RecordOverflowAlertCoreClass;
 export {};