mdt-charts 1.28.2 → 1.29.1

package/lib/config/config.d.ts

@@ -2,11 +2,10 @@ declare type DataType = string;
 export declare type MdtChartsIconElement = () => HTMLElement;
 export declare type AxisPosition = "start" | "end";
 export declare type ChartOrientation = "vertical" | "horizontal";
-export declare type ChartNotation = "2d" | "polar" | "interval";
+export declare type ChartNotation = "2d" | "polar";
 export declare type ChartType = "bar" | "line" | "area" | "donut" | "gantt";
 export declare type TwoDimensionalChartType = "line" | "bar" | "area" | "dot";
 export declare type PolarChartType = "donut";
-export declare type IntervalChartType = "gantt";
 export declare type EmbeddedLabelType = "none" | "key" | "value";
 export declare type ValueLabelsCollisionMode = "none" | "hide";
 export declare type TwoDimLegendPosition = "top" | "bottom";
@@ -22,7 +21,7 @@ export interface MdtChartsDataSource {
     [source: string]: MdtChartsDataRow[];
 }
 export declare type AxisLabelPosition = "straight" | "rotated";
-export declare type MdtChartsConfigOptions = MdtChartsPolarOptions | MdtChartsTwoDimensionalOptions | MdtChartsIntervalOptions;
+export declare type MdtChartsConfigOptions = MdtChartsPolarOptions | MdtChartsTwoDimensionalOptions;
 export interface MdtChartsConfig {
     canvas: ChartBlockCanvas;
     options: MdtChartsConfigOptions;
@@ -39,15 +38,13 @@ export interface NewSize {
     width?: number;
     height?: number;
 }
-interface BasicOptions {
-    tooltip?: TooltipOptions;
-    data: MdtChartsBasicDataOptions;
-}
-interface GraphicNotationOptions extends BasicOptions {
+interface GraphicNotationOptions {
     data: DataOptions;
     legend: MdtChartsTwoDimLegend;
     title?: Title;
     selectable: boolean;
+    tooltip?: TooltipOptions;
+    recordOverflowAlert?: RecordOverflowAlertOptions;
 }
 export interface MdtChartsTwoDimensionalOptions extends GraphicNotationOptions {
     type: "2d";
@@ -61,19 +58,25 @@ export interface MdtChartsPolarOptions extends GraphicNotationOptions {
     type: "polar";
     chart: PolarChart;
 }
-export interface MdtChartsIntervalOptions extends GraphicNotationOptions {
-    type: "interval";
-    axis: IntervalAxis;
-    chart: IntervalChart;
-    additionalElements: AdditionalElements;
-    orientation: ChartOrientation;
-}
 export interface Legend {
     show: boolean;
 }
 export interface MdtChartsTwoDimLegend extends Legend {
     position?: TwoDimLegendPosition;
 }
+export interface RecordOverflowAlertOptions {
+    textContent: RecordOverflowBlockTextContent;
+}
+export interface RecordOverflowVariationTextContent {
+    one: string;
+    twoToFour: string;
+    tenToTwenty: string;
+    other: string;
+}
+export interface RecordOverflowFunctionTextContent {
+    create: (overflowRecordsAmount: number) => string;
+}
+export declare type RecordOverflowBlockTextContent = RecordOverflowVariationTextContent | RecordOverflowFunctionTextContent;
 export interface TitleFunctionParams {
     data: MdtChartsDataRow[];
 }
@@ -209,12 +212,6 @@ export interface ValueLabelsStyleOptions {
     fontSize?: number;
     color?: string;
 }
-export interface IntervalAxis {
-    key: DiscreteAxisOptions;
-    value: DateAxisOptions;
-}
-interface DateAxisOptions extends AxisOptions {
-}
 interface MdtChartsLineLikeChart {
     markers: MarkersOptions;
     lineStyles?: MdtChartsLineLikeChartStyles;
@@ -282,10 +279,6 @@ export interface PolarChart {
     data: PolarChartData;
     aggregator?: MdtChartsDonutAggregator;
 }
-export interface IntervalChart {
-    type: IntervalChartType;
-    data: IntervalChartData;
-}
 export interface TwoDimensionalChartData {
     valueFields: TwoDimValueField[];
     valueGroup?: TwoDimensionalValueGroup;
@@ -326,8 +319,4 @@ export interface MdtChartsAggregatorContent {
     value?: string | number;
     title?: string;
 }
-interface IntervalChartData {
-    valueField1: MdtChartsValueField;
-    valueField2: MdtChartsValueField;
-}
 export {};

package/lib/engine/contentManager/contentManager.d.ts

@@ -2,11 +2,12 @@ import { Model } from "../../model/model";
 import { Engine } from "../engine";
 import { Block } from "../block/block";
 import { MdtChartsDataSource } from "../../config/config";
+import { ChartClearSelectionOptions } from "../filterManager/filterEventManager";
 export declare class ContentManager {
     private manager;
     constructor(model: Model);
     render(model: Model, engine: Engine): void;
     updateData(block: Block, model: Model, newData: MdtChartsDataSource): void;
     updateColors(engine: Engine, model: Model): void;
-    clearSelection(engine: Engine, model: Model): void;
+    clearSelection(engine: Engine, model: Model, options?: ChartClearSelectionOptions): void;
 }

package/lib/engine/contentManager/contentManager.js

@@ -12,7 +12,7 @@ export class ContentManager {
     updateColors(engine, model) {
         this.manager.updateColors(engine.block, model);
     }
-    clearSelection(engine, model) {
-        this.manager.clearSelection(engine.block.filterEventManager, model);
+    clearSelection(engine, model, options) {
+        this.manager.clearSelection(engine.block.filterEventManager, model, options);
     }
 }

package/lib/engine/contentManager/contentManagerFactory.d.ts

@@ -2,12 +2,12 @@ import { ChartNotation, MdtChartsDataSource } from "../../config/config";
 import { Model } from "../../model/model";
 import { Block } from "../block/block";
 import { Engine } from "../engine";
-import { FilterEventManager } from "../filterManager/filterEventManager";
+import { ChartClearSelectionOptions, FilterEventManager } from "../filterManager/filterEventManager";
 export interface ChartContentManager {
     render(engine: Engine, model: Model): void;
     updateData(block: Block, model: Model, newData: MdtChartsDataSource): void;
     updateColors(block: Block, model: Model): void;
-    clearSelection(filterEventManager: FilterEventManager, model: Model): void;
+    clearSelection(filterEventManager: FilterEventManager, model: Model, options?: ChartClearSelectionOptions): void;
 }
 export declare class ContentManagerFactory {
     private managers;

package/lib/engine/engine.d.ts

@@ -1,6 +1,6 @@
 import { Block } from "./block/block";
 import { Model } from "../model/model";
-import { FilterCallback } from "./filterManager/filterEventManager";
+import { ChartClearSelectionOptions, FilterCallback } from "./filterManager/filterEventManager";
 import { MdtChartsDataSource } from "../config/config";
 export declare class Engine {
     private filterCallback;
@@ -15,7 +15,7 @@ export declare class Engine {
     updateFullBlock(model: Model, data: MdtChartsDataSource): void;
     destroy(): void;
     updateData(model: Model, newData: MdtChartsDataSource): void;
-    clearSelection(model: Model): void;
+    clearSelection(model: Model, options?: ChartClearSelectionOptions): void;
     updateColors(model: Model): void;
     private renderCharts;
     private setFilterEventManager;

package/lib/engine/engine.js

@@ -47,8 +47,8 @@ export class Engine {
             }
         }
     }
-    clearSelection(model) {
-        this.contentManager.clearSelection(this, model);
+    clearSelection(model, options) {
+        this.contentManager.clearSelection(this, model, options);
     }
     updateColors(model) {
         this.contentManager.updateColors(this, model);

package/lib/engine/features/legend/legend.d.ts

@@ -20,7 +20,6 @@ export declare class Legend {
     static readonly labelClass = "legend-label";
     static readonly label2DClass = "legend-2d-label";
     static readonly labelPolarClass = "legend-polar-label";
-    static readonly labelIntervalClass = "legend-interval-label";
     static readonly itemClass = "legend-item";
     static readonly markerClass = "legend-marker";
     static readonly markerCircle = "legend-circle";

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

@@ -103,7 +103,6 @@ Legend.objectClass = "legend-object";
 Legend.labelClass = "legend-label";
 Legend.label2DClass = "legend-2d-label";
 Legend.labelPolarClass = "legend-polar-label";
-Legend.labelIntervalClass = "legend-interval-label";
 Legend.itemClass = "legend-item";
 Legend.markerClass = "legend-marker";
 Legend.markerCircle = "legend-circle";

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

@@ -90,8 +90,7 @@ export class LegendHelper {
     static getLegendClassByChartNotation(chartNotation) {
         const legendClasses = {
             "2d": Legend.label2DClass,
-            polar: Legend.labelPolarClass,
-            interval: Legend.labelIntervalClass
+            polar: Legend.labelPolarClass
         };
         return `${Legend.labelClass} ${legendClasses[chartNotation]}`;
     }

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

@@ -1,27 +1,9 @@
+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;
+    render(block: Block, options: RecordOverflowAlertModel): void;
+    update(block: Block, options: RecordOverflowAlertModel): void;
     private setAlertPosition;
 }
 export declare const RecordOverflowAlertCore: RecordOverflowAlertCoreClass;

package/lib/engine/features/recordOverflowAlert/recordOverflowAlertCore.js

@@ -3,41 +3,28 @@ class RecordOverflowAlertCoreClass {
         this.blockClass = "record-overflow-alert";
     }
     render(block, options) {
-        const alertBlock = block
-            .getWrapper()
-            .append("div")
-            .attr("class", this.blockClass)
-            .text(this.getAlertText(options));
-        this.setAlertPosition(alertBlock, options.positionAttrs);
+        if (options.show) {
+            const alertBlock = block
+                .getWrapper()
+                .append("div")
+                .attr("class", this.blockClass)
+                .text(options.textContent);
+            this.setAlertPosition(alertBlock, options.positionAttrs);
+        }
     }
     update(block, options) {
-        let alertBlock = block.getWrapper().select(`div.${this.blockClass}`);
+        let alertBlock = block.getWrapper().select(`.${this.blockClass}`);
         if (alertBlock.empty()) {
-            if (options.hidedRecordsAmount === 0)
-                return;
-            else
+            if (options.show)
                 this.render(block, options);
         }
         else {
-            if (options.hidedRecordsAmount === 0)
-                alertBlock.remove();
+            if (options.show)
+                alertBlock.text(options.textContent);
             else
-                alertBlock.text(this.getAlertText(options));
+                alertBlock.remove();
         }
     }
-    getAlertText(options) {
-        return `+ ${options.hidedRecordsAmount} ${this.getWordTextEndingByAmount(options.hidedRecordsAmount, options.text)}`;
-    }
-    getWordTextEndingByAmount(hidedRecordsAmount, text) {
-        const lastDigit = hidedRecordsAmount % 10;
-        if (hidedRecordsAmount >= 10 && hidedRecordsAmount <= 20)
-            return text.tenToTwenty;
-        if (lastDigit === 1)
-            return text.one;
-        if (lastDigit >= 2 && lastDigit <= 4)
-            return text.twoToFour;
-        return text.other;
-    }
     setAlertPosition(alertBlock, attrs) {
         alertBlock
             .style("position", "absolute")

package/lib/engine/filterManager/filterEventManager.d.ts

@@ -11,6 +11,10 @@ export interface SelectDetails {
 interface FilterEventMap {
     change: string[];
 }
+export interface ChartClearSelectionOptions {
+    /** @default true */
+    firePublicEvent?: boolean;
+}
 export declare class FilterEventManager {
     private callback;
     private fullDataset;
@@ -23,8 +27,8 @@ export declare class FilterEventManager {
     getSelectedKeys(): string[];
     updateData(newDataset: MdtChartsDataRow[]): void;
     isSelected(keyValue: string): boolean;
-    clearKeysFor2D(options: TwoDimensionalOptionsModel): void;
-    clearKeysForPolar(margin: BlockMargin, blockSize: Size, options: PolarOptionsModel): void;
+    clearKeysFor2D(options: TwoDimensionalOptionsModel, clearSelectionOptions?: ChartClearSelectionOptions): void;
+    clearKeysForPolar(margin: BlockMargin, blockSize: Size, options: PolarOptionsModel, clearSelectionOptions?: ChartClearSelectionOptions): void;
     private setKey;
     private addId;
     private removeId;

package/lib/engine/filterManager/filterEventManager.js

@@ -25,16 +25,18 @@ export class FilterEventManager {
     isSelected(keyValue) {
         return this.selectedKeys.findIndex((key) => key === keyValue) !== -1;
     }
-    clearKeysFor2D(options) {
+    clearKeysFor2D(options, clearSelectionOptions) {
+        var _a;
         this.selectedKeys = [];
-        if (this.callback)
+        if (((_a = clearSelectionOptions === null || clearSelectionOptions === void 0 ? void 0 : clearSelectionOptions.firePublicEvent) !== null && _a !== void 0 ? _a : true) && this.callback)
             this.callback([]);
         this.eventEmitter.emit("change", this.selectedKeys);
         SelectHighlighter.clear2D(this.block, options);
     }
-    clearKeysForPolar(margin, blockSize, options) {
+    clearKeysForPolar(margin, blockSize, options, clearSelectionOptions) {
+        var _a;
         this.selectedKeys = [];
-        if (this.callback)
+        if (((_a = clearSelectionOptions === null || clearSelectionOptions === void 0 ? void 0 : clearSelectionOptions.firePublicEvent) !== null && _a !== void 0 ? _a : true) && this.callback)
             this.callback([]);
         this.eventEmitter.emit("change", this.selectedKeys);
         SelectHighlighter.clearPolar(margin, blockSize, this.block, options, Donut.getAllArcGroups(this.block), options.chartCanvas);

package/lib/engine/polarNotation/polarManager.d.ts

@@ -3,11 +3,11 @@ import { Block } from "../block/block";
 import { Engine } from "../engine";
 import { MdtChartsDataSource } from "../../config/config";
 import { ChartContentManager } from "../contentManager/contentManagerFactory";
-import { FilterEventManager } from "../filterManager/filterEventManager";
+import { ChartClearSelectionOptions, FilterEventManager } from "../filterManager/filterEventManager";
 export declare class PolarManager implements ChartContentManager {
     render(engine: Engine, model: Model<PolarOptionsModel>): void;
     updateData(block: Block, model: Model<PolarOptionsModel>, data: MdtChartsDataSource): void;
     updateColors(block: Block, model: Model<PolarOptionsModel>): void;
-    clearSelection(filterEventManager: FilterEventManager, model: Model<PolarOptionsModel>): void;
+    clearSelection(filterEventManager: FilterEventManager, model: Model<PolarOptionsModel>, options?: ChartClearSelectionOptions): void;
     private renderCharts;
 }

package/lib/engine/polarNotation/polarManager.js

@@ -4,7 +4,7 @@ import { ElementHighlighter } from "../elementHighlighter/elementHighlighter";
 import { Tooltip } from "../features/tolltip/tooltip";
 import { Aggregator } from "../features/aggregator/aggregator";
 import { Donut } from "./donut/donut";
-import { PolarRecordOverflowAlert } from "./extenders/polarRecordOverflowAlert";
+import { RecordOverflowAlertCore } from "../features/recordOverflowAlert/recordOverflowAlertCore";
 export class PolarManager {
     render(engine, model) {
         const options = model.options;
@@ -15,10 +15,7 @@ export class PolarManager {
         Tooltip.render(engine.block, model, engine.data, model.otherComponents.tooltipBlock);
         engine.block.filterEventManager.setListenerPolar(model.chartBlock.margin, model.blockCanvas.size, options);
         if (model.dataSettings.scope.hidedRecordsAmount !== 0)
-            PolarRecordOverflowAlert.render(engine.block, {
-                hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
-                legendPosition: model.options.legend.position
-            });
+            RecordOverflowAlertCore.render(engine.block, options.recordOverflowAlert);
         engine.block.getSvg().on("click", (e) => {
             if (e.target === engine.block.getSvg().node())
                 this.clearSelection(engine.block.filterEventManager, model);
@@ -40,17 +37,14 @@ export class PolarManager {
         });
         Aggregator.update(block, options.charts[0].data.valueField, options.chartCanvas.aggregator);
         Legend.get().update(block, data, model);
-        PolarRecordOverflowAlert.update(block, {
-            hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
-            legendPosition: model.options.legend.position
-        });
+        RecordOverflowAlertCore.update(block, options.recordOverflowAlert);
     }
     updateColors(block, model) {
         Legend.get().updateColors(block, model.options);
         Donut.updateColors(block, model.options.charts[0]);
     }
-    clearSelection(filterEventManager, model) {
-        filterEventManager.clearKeysForPolar(model.chartBlock.margin, model.blockCanvas.size, model.options);
+    clearSelection(filterEventManager, model, options) {
+        filterEventManager.clearKeysForPolar(model.chartBlock.margin, model.blockCanvas.size, model.options, options);
     }
     renderCharts(block, charts, data, dataSource, margin, blockSize, donutSettings) {
         charts.forEach((chart) => {

package/lib/engine/twoDimensionalNotation/twoDimensionalManager.d.ts

@@ -3,7 +3,7 @@ import { Model, TwoDimensionalOptionsModel } from "../../model/model";
 import { Block } from "../block/block";
 import { ChartContentManager } from "../contentManager/contentManagerFactory";
 import { Engine } from "../engine";
-import { FilterEventManager } from "../filterManager/filterEventManager";
+import { ChartClearSelectionOptions, FilterEventManager } from "../filterManager/filterEventManager";
 export declare class TwoDimensionalManager implements ChartContentManager {
     private canvasValueLabels?;
     private linearGradientDef?;
@@ -11,7 +11,7 @@ export declare class TwoDimensionalManager implements ChartContentManager {
     render(engine: Engine, model: Model<TwoDimensionalOptionsModel>): void;
     updateData(block: Block, model: Model<TwoDimensionalOptionsModel>, data: MdtChartsDataSource): void;
     updateColors(block: Block, model: Model<TwoDimensionalOptionsModel>): void;
-    clearSelection(filterEventManager: FilterEventManager, model: Model<TwoDimensionalOptionsModel>): void;
+    clearSelection(filterEventManager: FilterEventManager, model: Model<TwoDimensionalOptionsModel>, options?: ChartClearSelectionOptions): void;
     private renderCharts;
     private updateCharts;
 }

package/lib/engine/twoDimensionalNotation/twoDimensionalManager.js

@@ -11,11 +11,11 @@ import { Helper } from "../helpers/helper";
 import { Area } from "./area/area";
 import { Bar } from "./bar/bar";
 import { BarHelper } from "./bar/barHelper";
-import { TwoDimRecordOverflowAlert } from "./extenders/twoDimRecordOverflowAlert";
 import { Line } from "./line/line";
 import { CanvasValueLabels } from "../../engine/features/valueLabels/valueLabels";
 import { LinearGradientDef } from "../../engine/block/defs/LinearGradientDef";
 import { CanvasDotChart } from "./dot/dotChart";
+import { RecordOverflowAlertCore } from "../features/recordOverflowAlert/recordOverflowAlertCore";
 export class TwoDimensionalManager {
     render(engine, model) {
         const options = model.options;
@@ -46,10 +46,7 @@ export class TwoDimensionalManager {
         Legend.get().render(engine.block, engine.data, options, model);
         Tooltip.render(engine.block, model, engine.data, model.otherComponents.tooltipBlock, scales);
         if (model.dataSettings.scope.hidedRecordsAmount !== 0)
-            TwoDimRecordOverflowAlert.render(engine.block, {
-                hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
-                chartOrientation: options.orient
-            });
+            RecordOverflowAlertCore.render(engine.block, options.recordOverflowAlert);
         engine.block.getSvg().on("click", (e) => {
             if (e.target === engine.block.getSvg().node())
                 this.clearSelection(engine.block.filterEventManager, model);
@@ -92,10 +89,7 @@ export class TwoDimensionalManager {
             block.filterEventManager.registerEventFor2D(scales.key, model.chartBlock.margin, model.blockCanvas.size, options);
             Tooltip.render(block, model, data, model.otherComponents.tooltipBlock, scales);
         });
-        TwoDimRecordOverflowAlert.update(block, {
-            hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
-            chartOrientation: options.orient
-        });
+        RecordOverflowAlertCore.update(block, options.recordOverflowAlert);
         if (this.canvasValueLabels)
             this.canvasValueLabels.update(scales, options.charts, data, model.options.data, options.valueLabels);
     }
@@ -112,8 +106,8 @@ export class TwoDimensionalManager {
                 Area.get({ staticSettings: model.options.chartSettings.lineLike }).updateColors(block, chart);
         });
     }
-    clearSelection(filterEventManager, model) {
-        filterEventManager.clearKeysFor2D(model.options);
+    clearSelection(filterEventManager, model, options) {
+        filterEventManager.clearKeysFor2D(model.options, options);
     }
     renderCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, chartSettings, blockSize) {
         block.svg.renderChartClipPath(margin, blockSize);

package/lib/main.d.ts

@@ -1,6 +1,10 @@
 import { MdtChartsConfig, MdtChartsDataSource, NewSize, Size } from "./config/config";
 import { DesignerConfig } from "./designer/designerConfig";
 import { FilterCallback } from "./engine/filterManager/filterEventManager";
+interface ChartClearSelectionPublicOptions {
+    /** @default true */
+    fireEvent?: boolean;
+}
 export interface IChart {
     /**
      * Рендер графика
@@ -29,7 +33,7 @@ export interface IChart {
     /**
      * Сброс выделения ключей
      */
-    clearSelection(): void;
+    clearSelection(options?: ChartClearSelectionPublicOptions): void;
 }
 export declare class Chart implements IChart {
     static chartCounter: number;
@@ -75,7 +79,7 @@ export declare class Chart implements IChart {
      * @param newColors Новые базовые цвета
      */
     updateColors(newColors: string[]): void;
-    clearSelection(): void;
+    clearSelection(options?: ChartClearSelectionPublicOptions): void;
     private registerResizeEvent;
     private removeResizeEvent;
     private resizeListener;

package/lib/main.js

@@ -71,8 +71,8 @@ export class Chart {
         this.model = assembleModel(this.config, this.data, this.designerConfig, this.id);
         this.engine.updateColors(this.model);
     }
-    clearSelection() {
-        this.engine.clearSelection(this.model);
+    clearSelection(options) {
+        this.engine.clearSelection(this.model, { firePublicEvent: options === null || options === void 0 ? void 0 : options.fireEvent });
     }
     registerResizeEvent() {
         window.addEventListener("resize", this.resizeHandler);

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

@@ -0,0 +1,4 @@
+import { RecordOverflowAlertOptions, RecordOverflowVariationTextContent } from "../../../config/config";
+import { RecordOverflowAlertModel } from "../../model";
+export declare function getTextVariationByNumber(hidedRecordsAmount: number, textVariation: RecordOverflowVariationTextContent): string;
+export declare function createRecordOverflowModel(hiddenRecordsAmount: number, defaultTextVariation: RecordOverflowVariationTextContent, options?: RecordOverflowAlertOptions): RecordOverflowAlertModel;

package/lib/model/featuresModel/recordOverflowModel/recordOverflowModel.js

@@ -0,0 +1,33 @@
+export function getTextVariationByNumber(hidedRecordsAmount, textVariation) {
+    const lastDigit = hidedRecordsAmount % 10;
+    if (hidedRecordsAmount >= 10 && hidedRecordsAmount <= 20)
+        return textVariation.tenToTwenty;
+    if (lastDigit === 1)
+        return textVariation.one;
+    if (lastDigit >= 2 && lastDigit <= 4)
+        return textVariation.twoToFour;
+    return textVariation.other;
+}
+export function createRecordOverflowModel(hiddenRecordsAmount, defaultTextVariation, options) {
+    var _a;
+    let textContent;
+    if ((_a = options === null || options === void 0 ? void 0 : options.textContent) === null || _a === void 0 ? void 0 : _a.create) {
+        textContent = (options === null || options === void 0 ? void 0 : options.textContent).create(hiddenRecordsAmount);
+    }
+    else if (options === null || options === void 0 ? void 0 : options.textContent) {
+        textContent = `+ ${hiddenRecordsAmount} ${getTextVariationByNumber(hiddenRecordsAmount, options.textContent)}`;
+    }
+    else {
+        textContent = `+ ${hiddenRecordsAmount} ${getTextVariationByNumber(hiddenRecordsAmount, defaultTextVariation)}`;
+    }
+    return hiddenRecordsAmount === 0
+        ? { show: false }
+        : {
+            show: true,
+            positionAttrs: {
+                bottom: "0",
+                right: "0"
+            },
+            textContent
+        };
+}

package/lib/model/model.d.ts

@@ -1,4 +1,4 @@
-import { ChartOrientation, MdtChartsColorField, IntervalChartType, PolarChartType, Size, TooltipOptions, TwoDimensionalChartType, AxisLabelPosition, ShowTickFn, MdtChartsDataRow, TwoDimensionalValueGroup, ValueLabelsCollisionMode, ValueLabelsRotationOptions } from "../config/config";
+import { ChartOrientation, MdtChartsColorField, PolarChartType, Size, TooltipOptions, TwoDimensionalChartType, AxisLabelPosition, ShowTickFn, MdtChartsDataRow, TwoDimensionalValueGroup, ValueLabelsCollisionMode, ValueLabelsRotationOptions } from "../config/config";
 import { DataType, DonutOptionsCanvas, Formatter, StaticLegendBlockCanvas, TooltipSettings, Transitions } from "../designer/designerConfig";
 import { BoundingRect } from "../engine/features/valueLabelsCollision/valueLabelsCollision";
 declare type AxisType = "key" | "value";
@@ -14,7 +14,7 @@ export declare type UnitsFromConfig = "%" | "px";
 export declare type ValueLabelAnchor = "start" | "middle" | "end";
 export declare type ValueLabelDominantBaseline = "hanging" | "middle" | "auto";
 export declare type GradientId = string;
-export declare type OptionsModel = TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel;
+export declare type OptionsModel = TwoDimensionalOptionsModel | PolarOptionsModel;
 export interface Model<O = OptionsModel> {
     blockCanvas: BlockCanvas;
     chartBlock: ChartBlockModel;
@@ -45,6 +45,7 @@ interface GraphicNotationOptionsModel extends BasicOptionsModel {
     title: OptionsModelTitle;
     selectable: boolean;
     defs: OptionsModelGradients;
+    recordOverflowAlert: RecordOverflowAlertModel;
 }
 export interface TwoDimensionalOptionsModel extends GraphicNotationOptionsModel {
     type: "2d";
@@ -61,15 +62,6 @@ export interface PolarOptionsModel extends GraphicNotationOptionsModel {
     charts: PolarChartModel[];
     chartCanvas: DonutChartSettings;
 }
-export interface IntervalOptionsModel extends GraphicNotationOptionsModel {
-    type: "interval";
-    scale: IScaleModel;
-    axis: IAxisModel;
-    charts: IntervalChartModel[];
-    additionalElements: AdditionalElementsOptions;
-    orient: ChartOrientation;
-    chartSettings: TwoDimChartElementsSettings;
-}
 export interface ILegendModel {
     position: LegendPosition;
 }
@@ -370,10 +362,6 @@ export interface TwoDimensionalChartModel extends ChartModel, TwoDimensionalLine
     legend: ChartLegendModel;
     valueLabels: TwoDimChartValueLabelsOptions;
 }
-export interface IntervalChartModel extends Omit<ChartModel, "legend"> {
-    type: IntervalChartType;
-    data: IntervalChartDataModel;
-}
 export interface PolarChartModel extends ChartModel {
     type: PolarChartType;
     data: PolarChartDataModel;
@@ -423,10 +411,6 @@ interface MarkersBaseSizeOptions {
     radius: number;
     borderSize: string;
 }
-interface IntervalChartDataModel {
-    valueField1: ValueField;
-    valueField2: ValueField;
-}
 export interface PolarChartDataModel {
     valueField: ValueField;
     colorField?: MdtChartsColorField;
@@ -466,4 +450,17 @@ export interface TitleBlockModel extends ComponentBlockModel {
 }
 interface LegendCanvasCoordinate extends ComponentBlockModel {
 }
+export declare type RecordOverflowAlertModel = {
+    show: false;
+} | {
+    show: true;
+    textContent: string;
+    positionAttrs: RecordOverflowAlertPositionAttrs;
+};
+export interface RecordOverflowAlertPositionAttrs {
+    top?: string;
+    bottom?: string;
+    right?: string;
+    left?: string;
+}
 export {};

package/lib/model/modelInstance/dataModel/dataModel.d.ts

@@ -1,6 +1,6 @@
 import { DataScope } from "../../model";
 import { DataRepositoryModel } from "./dataRepository";
-export declare const DEFAULT_MAX_RECORDS_AMOUNT = 50;
+export declare const DEFAULT_MAX_RECORDS_AMOUNT = 100;
 export declare class DataModelInstance {
     readonly repository: DataRepositoryModel;
     private maxRecordsAmount;

package/lib/model/modelInstance/dataModel/dataModel.js

@@ -1,5 +1,5 @@
 import { DataRepositoryModel } from "./dataRepository";
-export const DEFAULT_MAX_RECORDS_AMOUNT = 50;
+export const DEFAULT_MAX_RECORDS_AMOUNT = 100;
 export class DataModelInstance {
     constructor() {
         this.maxRecordsAmount = DEFAULT_MAX_RECORDS_AMOUNT;

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

@@ -1,6 +1,7 @@
 import { ChartStyleModelService } from "../../chartStyleModel/chartStyleModel";
 import { DonutModel } from "./donut/donutModel";
 import { TitleConfigReader } from "../../modelInstance/titleConfigReader";
+import { createRecordOverflowModel } from "../../featuresModel/recordOverflowModel/recordOverflowModel";
 export const MIN_DONUT_BLOCK_SIZE = 120;
 export class PolarModel {
     static getOptions(options, designerConfig, modelInstance) {
@@ -17,7 +18,13 @@ export class PolarModel {
             legend: modelInstance.canvasModel.legendCanvas.getModel(),
             tooltip: options.tooltip,
             chartCanvas: this.getDonutSettings(designerConfig.canvas.chartOptions.donut, options.chart, modelInstance.dataModel.repository.getRawRows()),
-            defs: { gradients: [] }
+            defs: { gradients: [] },
+            recordOverflowAlert: createRecordOverflowModel(modelInstance.dataModel.getScope().hidedRecordsAmount, {
+                one: "категория",
+                twoToFour: "категории",
+                tenToTwenty: "категорий",
+                other: "категорий"
+            }, options.recordOverflowAlert)
         };
     }
     //TODO: type for returned value

package/lib/model/notations/twoDimensionalModel.js

@@ -7,6 +7,7 @@ import { calculateBarIndexes, getAreaViewOptions, getBarViewOptions, getLegendMa
 import { calculateValueLabelAlignment, ValueLabelCoordinateCalculator } from "../../model/featuresModel/valueLabelsModel/valueLabelsModel";
 import { TwoDimensionalModelHelper } from "../helpers/twoDimensionalModelHelper";
 import { TitleConfigReader } from "../modelInstance/titleConfigReader";
+import { createRecordOverflowModel } from "../featuresModel/recordOverflowModel/recordOverflowModel";
 export class TwoDimensionalModel {
     static getOptions(configReader, designerConfig, modelInstance) {
         const options = configReader.options;
@@ -24,6 +25,7 @@ export class TwoDimensionalModel {
         const keyAxis = AxisModel.getKeyAxis(options, modelInstance.dataModel.repository.getScopedFullSource(), designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip, () => scaleValueInfo.scaleFn(0));
         const charts = this.getChartsModel(options.charts, configReader, options.orientation, designerConfig, modelInstance.dataModel.repository, keyAxis.orient, canvasModel, options.data.keyField.name, modelInstance);
         const titleConfig = TitleConfigReader.create(options.title, modelInstance);
+        const isHorizontal = options.orientation === "horizontal";
         return {
             legend: canvasModel.legendCanvas.getModel(),
             title: {
@@ -45,7 +47,13 @@ export class TwoDimensionalModel {
             valueLabels: TwoDimensionalModelHelper.getValueLabels(options.valueLabels, canvasModel, options.orientation, configReader.getValueLabelsStyleModel()),
             defs: {
                 gradients: TwoDimensionalModelHelper.getGradientDefs(charts, keyAxis.orient, options.orientation, modelInstance.version.getVersionNumber())
-            }
+            },
+            recordOverflowAlert: createRecordOverflowModel(modelInstance.dataModel.getScope().hidedRecordsAmount, {
+                one: isHorizontal ? "строка" : "столбец",
+                twoToFour: isHorizontal ? "строки" : "столбца",
+                tenToTwenty: isHorizontal ? "строк" : "столбцов",
+                other: isHorizontal ? "строк" : "столбцов"
+            }, options.recordOverflowAlert)
         };
     }
     static getChartsEmbeddedLabelsFlag(charts, chartOrientation) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mdt-charts",
-	"version": "1.28.2",
+	"version": "1.29.1",
 	"description": "",
 	"main": "lib/main.js",
 	"scripts": {

package/lib/engine/polarNotation/extenders/polarRecordOverflowAlert.d.ts

@@ -1,15 +0,0 @@
-import { LegendPosition } from "../../../model/model";
-import { Block } from "../../block/block";
-interface PolarRecordOverflowAlertOptions {
-    hidedRecordsAmount: number;
-    legendPosition: LegendPosition;
-}
-declare class PolarRecordOverflowAlertClass {
-    private readonly text;
-    render(block: Block, options: PolarRecordOverflowAlertOptions): void;
-    update(block: Block, options: PolarRecordOverflowAlertOptions): void;
-    private buildCoreOptions;
-    private getPositionAttrs;
-}
-export declare const PolarRecordOverflowAlert: PolarRecordOverflowAlertClass;
-export {};

package/lib/engine/polarNotation/extenders/polarRecordOverflowAlert.js

@@ -1,40 +0,0 @@
-import { RecordOverflowAlertCore } from "../../features/recordOverflowAlert/recordOverflowAlertCore";
-class PolarRecordOverflowAlertClass {
-    constructor() {
-        this.text = {
-            one: "категория",
-            twoToFour: "категории",
-            tenToTwenty: "категорий",
-            other: "категорий"
-        };
-    }
-    render(block, options) {
-        RecordOverflowAlertCore.render(block, this.buildCoreOptions(options));
-    }
-    update(block, options) {
-        RecordOverflowAlertCore.update(block, this.buildCoreOptions(options));
-    }
-    buildCoreOptions(options) {
-        return {
-            hidedRecordsAmount: options.hidedRecordsAmount,
-            text: this.text,
-            positionAttrs: this.getPositionAttrs(options)
-        };
-    }
-    getPositionAttrs(options) {
-        const position = options.legendPosition === "off" ? "bottom" : options.legendPosition;
-        if (position === "right") {
-            return {
-                bottom: "0",
-                right: "0"
-            };
-        }
-        if (position === "bottom") {
-            return {
-                bottom: "0",
-                left: "0"
-            };
-        }
-    }
-}
-export const PolarRecordOverflowAlert = new PolarRecordOverflowAlertClass();

package/lib/engine/twoDimensionalNotation/extenders/twoDimRecordOverflowAlert.d.ts

@@ -1,15 +0,0 @@
-import { ChartOrientation } from "../../../config/config";
-import { Block } from "../../block/block";
-interface TwoDimRecordOverflowAlertOptions {
-    hidedRecordsAmount: number;
-    chartOrientation: ChartOrientation;
-}
-declare class TwoDimRecordOverflowAlertClass {
-    render(block: Block, options: TwoDimRecordOverflowAlertOptions): void;
-    update(block: Block, options: TwoDimRecordOverflowAlertOptions): void;
-    private buildCoreOptions;
-    private getText;
-    private getPositionAttrs;
-}
-export declare const TwoDimRecordOverflowAlert: TwoDimRecordOverflowAlertClass;
-export {};

package/lib/engine/twoDimensionalNotation/extenders/twoDimRecordOverflowAlert.js

@@ -1,32 +0,0 @@
-import { RecordOverflowAlertCore } from "../../features/recordOverflowAlert/recordOverflowAlertCore";
-class TwoDimRecordOverflowAlertClass {
-    render(block, options) {
-        RecordOverflowAlertCore.render(block, this.buildCoreOptions(options));
-    }
-    update(block, options) {
-        RecordOverflowAlertCore.update(block, this.buildCoreOptions(options));
-    }
-    buildCoreOptions(options) {
-        return {
-            hidedRecordsAmount: options.hidedRecordsAmount,
-            text: this.getText(options.chartOrientation),
-            positionAttrs: this.getPositionAttrs()
-        };
-    }
-    getText(chartOrientation) {
-        const isHorizontal = chartOrientation === "horizontal";
-        return {
-            one: isHorizontal ? "строка" : "столбец",
-            twoToFour: isHorizontal ? "строки" : "столбца",
-            tenToTwenty: isHorizontal ? "строк" : "столбцов",
-            other: isHorizontal ? "строк" : "столбцов"
-        };
-    }
-    getPositionAttrs() {
-        return {
-            right: "0px",
-            top: "0px"
-        };
-    }
-}
-export const TwoDimRecordOverflowAlert = new TwoDimRecordOverflowAlertClass();