mdt-charts 1.11.0 → 1.12.2

package/lib/config/config.d.ts

@@ -14,9 +14,10 @@ export declare type MdtChartsDataRow = {
 export interface MdtChartsDataSource {
     [source: string]: MdtChartsDataRow[];
 }
+export declare type AxisLabelPosition = "straight" | "rotated";
 export interface MdtChartsConfig {
     canvas: ChartBlockCanvas;
-    options: PolarOptions | TwoDimensionalOptions | IntervalOptions;
+    options: MdtChartsPolarOptions | MdtChartsTwoDimensionalOptions | IntervalOptions;
 }
 export interface ChartBlockCanvas {
     size: Size;
@@ -37,14 +38,14 @@ interface Options {
     selectable: boolean;
     tooltip?: TooltipOptions;
 }
-export interface TwoDimensionalOptions extends Options {
+export interface MdtChartsTwoDimensionalOptions extends Options {
     type: '2d';
     axis: TwoDimensionalAxis;
     additionalElements: AdditionalElements;
     charts: TwoDimensionalChart[];
     orientation: ChartOrientation;
 }
-export interface PolarOptions extends Options {
+export interface MdtChartsPolarOptions extends Options {
     type: 'polar';
     chart: PolarChart;
 }
@@ -61,6 +62,7 @@ export interface Legend {
 export interface DataOptions {
     dataSource: string;
     keyField: MdtChartsField;
+    maxRecordsAmount?: number;
 }
 export interface MdtChartsField {
     name: string;
@@ -105,6 +107,10 @@ export interface NumberDomain {
     end: number;
 }
 export interface DiscreteAxisOptions extends AxisOptions {
+    labels?: MdtChartsDiscreteAxisLabel;
+}
+export interface MdtChartsDiscreteAxisLabel {
+    position?: AxisLabelPosition;
 }
 export interface IntervalAxis {
     key: DiscreteAxisOptions;

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

@@ -3,12 +3,21 @@ import { MdtChartsDataSource } from "../../../config/config";
 import { IntervalOptionsModel, Model, PolarOptionsModel, TwoDimensionalOptionsModel } from "../../../model/model";
 import { Block } from "../../block/block";
 import { SelectionCondition } from "../../helpers/domHelper";
+export interface LegendContentRenderingOptions {
+    wrapperClasses: string[];
+    shouldCropLabels: boolean;
+    itemsOptions: {
+        wrapperClasses: string[];
+        markerClass: string;
+        labelClass: string;
+    };
+}
 export declare class Legend {
     static readonly objectClass = "legend-object";
     static readonly labelClass = "legend-label";
     static readonly itemClass = "legend-item";
     static readonly markerClass = "legend-circle";
-    private static readonly legendBlockClass;
+    static readonly legendBlockClass = "legend-block";
     static render(block: Block, data: MdtChartsDataSource, options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel, model: Model): void;
     static update(block: Block, data: MdtChartsDataSource, model: Model): void;
     static updateColors(block: Block, options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel): void;

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

@@ -1,4 +1,3 @@
-import { select } from "d3-selection";
 import { ColorReader } from "../../colorReader/colorReader";
 import { SelectionCondition } from "../../helpers/domHelper";
 import { LegendDomHelper } from "./legendDomHelper";
@@ -41,8 +40,8 @@ export class Legend {
     static setContent(block, data, options, legendObject) {
         const items = LegendHelper.getLegendItemsContent(options, data);
         const colors = LegendHelper.getMarksColor(options, data[options.data.dataSource]);
-        const itemsDirection = LegendHelper.getLegendItemsDirection(options.type, options.legend.position);
-        const itemBlocks = this.renderContent(legendObject, items, colors, itemsDirection, options.legend.position);
+        const renderingOptions = LegendHelper.getContentRenderingOptions(options.type, options.legend.position);
+        const itemBlocks = this.renderContent(legendObject, items, colors, renderingOptions);
         if (options.type === 'polar') {
             LegendEventsManager.setListeners(block, options.data.keyField.name, itemBlocks, options.selectable);
         }
@@ -58,36 +57,25 @@ export class Legend {
         this.fillCoordinate(legendObject, legendCoordinate);
         return legendObject;
     }
-    static renderContent(legendObject, items, colorPalette, itemsDirection, position) {
-        const wrapper = legendObject.append('xhtml:div')
-            .attr('class', Legend.legendBlockClass);
-        wrapper
-            .style('height', '100%')
-            .style('display', 'flex');
-        if (itemsDirection === 'column') {
-            wrapper.style('flex-direction', 'column');
-            if (position === 'right')
-                wrapper.style('justify-content', 'center');
-        }
+    static renderContent(foreignObject, items, colorPalette, options) {
+        const wrapper = foreignObject.append('xhtml:div');
+        wrapper.classed(options.wrapperClasses.join(" "), true);
         const itemWrappers = wrapper
             .selectAll(`.${this.itemClass}`)
             .data(items)
             .enter()
             .append('div');
-        const thisClass = this;
-        itemWrappers.each(function (d, i) {
-            select(this).attr('class', `${thisClass.itemClass} ${LegendHelper.getItemClasses(itemsDirection, position, i)}`);
-        });
+        itemWrappers.classed(options.itemsOptions.wrapperClasses.join(" "), true);
         itemWrappers
             .append('span')
-            .attr('class', this.markerClass);
+            .classed(options.itemsOptions.markerClass, true);
         LegendDomHelper.setItemsColors(itemWrappers, colorPalette);
         itemWrappers
             .append('span')
-            .attr('class', LegendHelper.getLegendLabelClassByPosition(position))
+            .attr('class', options.itemsOptions.labelClass)
             .text(d => d);
-        if (itemsDirection === 'row')
-            LegendDomHelper.cropRowLabels(legendObject, itemWrappers);
+        if (options.shouldCropLabels)
+            LegendDomHelper.cropRowLabels(foreignObject, itemWrappers);
         return itemWrappers;
     }
     static getObject(block) {

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

@@ -1,6 +1,8 @@
 import { ChartNotation, MdtChartsDataRow, MdtChartsDataSource, Size } from "../../../config/config";
 import { LegendItemsDirection } from "../../../model/featuresModel/legendModel/legendCanvasModel";
 import { IntervalOptionsModel, LegendBlockModel, LegendPosition, Orient, PolarOptionsModel, TwoDimensionalOptionsModel } from "../../../model/model";
+import { LegendContentRenderingOptions } from "./legend";
+import { LegendHelperService } from "./legendHelperService";
 export interface LegendCoordinate {
     x: number;
     y: number;
@@ -8,14 +10,11 @@ export interface LegendCoordinate {
     width: number;
 }
 export declare class LegendHelper {
+    static service: LegendHelperService;
     static getLegendItemsContent(options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel, data: MdtChartsDataSource): string[];
     static getMarksColor(options: TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel, dataRows?: MdtChartsDataRow[]): string[];
     static getMaxItemWidth(legendBlockWidth: string, marginsLeft: number[], itemsDirection: LegendItemsDirection): number;
-    static getItemClasses(itemsDirection: LegendItemsDirection, position: LegendPosition, index: number): string;
-    static getLegendItemClassByDirection(itemsDirection: LegendItemsDirection): string;
-    static getLegendItemsMarginClass(legendPosition: LegendPosition): string;
-    static getLegendLabelClassByPosition(position: LegendPosition): string;
-    static getLegendItemsDirection(chartNotation: ChartNotation, legendPosition: LegendPosition): LegendItemsDirection;
     static getSumOfItemsWidths(itemsWidth: number[], marginsLeft: number[]): number;
     static getLegendCoordinateByPosition(legendPosition: Orient, legendBlockModel: LegendBlockModel, blockSize: Size): LegendCoordinate;
+    static getContentRenderingOptions(chartNotation: ChartNotation, legendPosition: LegendPosition): LegendContentRenderingOptions;
 }

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

@@ -1,5 +1,6 @@
 import { Helper } from '../../helpers/helper';
 import { Legend } from "./legend";
+import { LegendHelperService } from "./legendHelperService";
 export class LegendHelper {
     static getLegendItemsContent(options, data) {
         if (options.type === '2d') {
@@ -40,29 +41,6 @@ export class LegendHelper {
         }
         return parseFloat(legendBlockWidth);
     }
-    static getItemClasses(itemsDirection, position, index) {
-        let cssClasses = this.getLegendItemClassByDirection(itemsDirection);
-        if (itemsDirection === 'column' && index !== 0)
-            cssClasses += ` ${this.getLegendItemsMarginClass(position)}`;
-        return cssClasses;
-    }
-    static getLegendItemClassByDirection(itemsDirection) {
-        return itemsDirection === 'column' ? 'legend-item-row' : 'legend-item-inline';
-    }
-    static getLegendItemsMarginClass(legendPosition) {
-        return legendPosition === 'right' ? 'mt-15' : 'mt-10';
-    }
-    static getLegendLabelClassByPosition(position) {
-        if (position === 'top' || position === 'bottom')
-            return `${Legend.labelClass} ${Legend.labelClass + '-nowrap'}`;
-        return Legend.labelClass;
-    }
-    static getLegendItemsDirection(chartNotation, legendPosition) {
-        if (legendPosition === 'right' || legendPosition === 'left')
-            return 'column';
-        else
-            return chartNotation === 'polar' ? 'column' : 'row';
-    }
     static getSumOfItemsWidths(itemsWidth, marginsLeft) {
         let sumOfItemsWidth = Helper.getSumOfNumeric(itemsWidth);
         sumOfItemsWidth += Helper.getSumOfNumeric(marginsLeft);
@@ -96,4 +74,22 @@ export class LegendHelper {
             coordinate.y = blockSize.height - legendModel.size - legendModel.margin.bottom;
         return coordinate;
     }
+    static getContentRenderingOptions(chartNotation, legendPosition) {
+        const itemsDirection = this.service.getLegendItemsDirection(legendPosition);
+        return {
+            wrapperClasses: [
+                Legend.legendBlockClass,
+                this.service.getWrapperClassByItemsDirection(itemsDirection),
+                this.service.getWrapperJustifyContentClass(itemsDirection, legendPosition),
+                this.service.getWrapperClassByWrappingItems(legendPosition, chartNotation)
+            ],
+            shouldCropLabels: chartNotation === "2d",
+            itemsOptions: {
+                markerClass: Legend.markerClass,
+                labelClass: this.service.getLegendLabelClassByPosition(legendPosition, chartNotation, Legend.labelClass),
+                wrapperClasses: [Legend.itemClass, this.service.getItemClasses(itemsDirection)]
+            }
+        };
+    }
 }
+LegendHelper.service = new LegendHelperService();

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

@@ -0,0 +1,12 @@
+import { ChartNotation } from "../../../config/config";
+import { LegendItemsDirection } from "../../../model/featuresModel/legendModel/legendCanvasModel";
+import { LegendPosition } from "../../../model/model";
+export declare class LegendHelperService {
+    getWrapperClassByItemsDirection(itemsDirection: LegendItemsDirection): "legend-block-column" | "legend-block-row";
+    getWrapperJustifyContentClass(itemsDirection: LegendItemsDirection, legendPosition: LegendPosition): "" | "legend-block-centered";
+    getWrapperClassByWrappingItems(legendPosition: LegendPosition, chartNotation: ChartNotation): "legend-wrapper-with-wrap" | "legend-wrapper-without-wrap";
+    getLegendLabelClassByPosition(legendPosition: LegendPosition, chartNotation: ChartNotation, initialLabelClass: string): string;
+    getItemClasses(itemsDirection: LegendItemsDirection): string;
+    getLegendItemsDirection(legendPosition: LegendPosition): LegendItemsDirection;
+    private doesLegendInTopBy2d;
+}

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

@@ -0,0 +1,30 @@
+export class LegendHelperService {
+    getWrapperClassByItemsDirection(itemsDirection) {
+        return itemsDirection === "column" ? "legend-block-column" : "legend-block-row";
+    }
+    getWrapperJustifyContentClass(itemsDirection, legendPosition) {
+        return itemsDirection === "column" && legendPosition === "right" ? "legend-block-centered" : "";
+    }
+    getWrapperClassByWrappingItems(legendPosition, chartNotation) {
+        if (this.doesLegendInTopBy2d(legendPosition, chartNotation)) {
+            return "legend-wrapper-without-wrap";
+        }
+        return "legend-wrapper-with-wrap";
+    }
+    getLegendLabelClassByPosition(legendPosition, chartNotation, initialLabelClass) {
+        if (this.doesLegendInTopBy2d(legendPosition, chartNotation))
+            return `${initialLabelClass} ${initialLabelClass + '-nowrap'}`;
+        return initialLabelClass;
+    }
+    getItemClasses(itemsDirection) {
+        return itemsDirection === 'column' ? 'legend-item-row' : 'legend-item-inline';
+    }
+    getLegendItemsDirection(legendPosition) {
+        if (legendPosition === 'right' || legendPosition === 'left')
+            return 'column';
+        return "row";
+    }
+    doesLegendInTopBy2d(legendPosition, chartNotation) {
+        return legendPosition === 'top' && chartNotation === "2d";
+    }
+}

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

@@ -0,0 +1,28 @@
+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;
+}
+export declare const RecordOverflowAlertCore: RecordOverflowAlertCoreClass;
+export {};

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

@@ -0,0 +1,50 @@
+class RecordOverflowAlertCoreClass {
+    constructor() {
+        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);
+    }
+    update(block, options) {
+        let alertBlock = block.getWrapper()
+            .select(`div.${this.blockClass}`);
+        if (alertBlock.empty()) {
+            if (options.hidedRecordsAmount === 0)
+                return;
+            else
+                this.render(block, options);
+        }
+        else {
+            if (options.hidedRecordsAmount === 0)
+                alertBlock.remove();
+            else
+                alertBlock.text(this.getAlertText(options));
+        }
+    }
+    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')
+            .style('left', attrs.left)
+            .style('right', attrs.right)
+            .style('top', attrs.top)
+            .style('bottom', attrs.bottom);
+    }
+}
+export const RecordOverflowAlertCore = new RecordOverflowAlertCoreClass();

package/lib/engine/intervalNotation/intervalManager.js

@@ -1,7 +1,6 @@
 import { Axis } from "../features/axis/axis";
 import { GridLine } from "../features/gridLine/gridLine";
 import { Legend } from "../features/legend/legend";
-import { RecordOverflowAlert } from "../features/recordOverflowAlert/recordOverflowAlert";
 import { Scale } from "../features/scale/scale";
 import { Title } from "../features/title/title";
 import { Tooltip } from "../features/tolltip/tooltip";
@@ -17,8 +16,6 @@ export class IntervalManager {
         Title.render(block, options.title, model.otherComponents.titleBlock, model.blockCanvas.size);
         Legend.render(block, data, options, model);
         Tooltip.render(block, model, data, model.otherComponents.tooltipBlock, scales);
-        if (model.dataSettings.scope.hidedRecordsAmount !== 0)
-            RecordOverflowAlert.render(block, model.dataSettings.scope.hidedRecordsAmount, 'top', options.orient);
     }
     static renderCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, chartSettings) {
         block.renderChartsBlock();

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,40 @@
+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/polarNotation/polarManager.js

@@ -1,10 +1,10 @@
 import { Legend } from "../features/legend/legend";
-import { RecordOverflowAlert } from "../features/recordOverflowAlert/recordOverflowAlert";
 import { Title } from "../features/title/title";
 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";
 export class PolarManager {
     static render(engine, model) {
         const options = model.options;
@@ -14,8 +14,11 @@ export class PolarManager {
         Legend.render(engine.block, engine.data, options, model);
         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 && model.options.legend.position !== 'off')
-            RecordOverflowAlert.render(engine.block, model.dataSettings.scope.hidedRecordsAmount, model.options.legend.position);
+        if (model.dataSettings.scope.hidedRecordsAmount !== 0)
+            PolarRecordOverflowAlert.render(engine.block, {
+                hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
+                legendPosition: model.options.legend.position
+            });
         engine.block.getSvg()
             .on('click', (e) => {
             if (e.target === engine.block.getSvg().node())
@@ -38,8 +41,10 @@ export class PolarManager {
         });
         Aggregator.update(block, data[options.data.dataSource], options.charts[0].data.valueField, options.chartCanvas.aggregator);
         Legend.update(block, data, model);
-        if (model.options.legend.position !== 'off')
-            RecordOverflowAlert.update(block, model.dataSettings.scope.hidedRecordsAmount, model.options.legend.position);
+        PolarRecordOverflowAlert.update(block, {
+            hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
+            legendPosition: model.options.legend.position
+        });
     }
     static updateColors(block, model) {
         Legend.updateColors(block, model.options);

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,32 @@
+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: '17px',
+            top: '1rem'
+        };
+    }
+}
+export const TwoDimRecordOverflowAlert = new TwoDimRecordOverflowAlertClass();

package/lib/engine/twoDimensionalNotation/twoDimensionalManager.js

@@ -3,7 +3,6 @@ import { Axis } from "../features/axis/axis";
 import { EmbeddedLabels } from "../features/embeddedLabels/embeddedLabels";
 import { GridLine } from "../features/gridLine/gridLine";
 import { Legend } from "../features/legend/legend";
-import { RecordOverflowAlert } from "../features/recordOverflowAlert/recordOverflowAlert";
 import { Scale } from "../features/scale/scale";
 import { TipBox } from "../features/tipBox/tipBox";
 import { Title } from "../features/title/title";
@@ -12,6 +11,7 @@ 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";
 export class TwoDimensionalManager {
     static render(engine, model) {
@@ -28,7 +28,10 @@ export class TwoDimensionalManager {
         Legend.render(engine.block, engine.data, options, model);
         Tooltip.render(engine.block, model, engine.data, model.otherComponents.tooltipBlock, scales);
         if (model.dataSettings.scope.hidedRecordsAmount !== 0)
-            RecordOverflowAlert.render(engine.block, model.dataSettings.scope.hidedRecordsAmount, 'top', options.orient);
+            TwoDimRecordOverflowAlert.render(engine.block, {
+                hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
+                chartOrientation: options.orient
+            });
         engine.block.getSvg()
             .on('click', (e) => {
             if (e.target === engine.block.getSvg().node())
@@ -54,7 +57,10 @@ export class TwoDimensionalManager {
             block.filterEventManager.registerEventFor2D(scales.key, model.chartBlock.margin, model.blockCanvas.size, options);
             Tooltip.render(block, model, data, model.otherComponents.tooltipBlock, scales);
         });
-        RecordOverflowAlert.update(block, model.dataSettings.scope.hidedRecordsAmount, 'top', options.orient);
+        TwoDimRecordOverflowAlert.update(block, {
+            hidedRecordsAmount: model.dataSettings.scope.hidedRecordsAmount,
+            chartOrientation: options.orient
+        });
     }
     static updateColors(block, model) {
         Legend.updateColors(block, model.options);

package/lib/model/{dataManagerModel.d.ts → dataManagerModel/dataManagerModel.d.ts}

@@ -1,13 +1,24 @@
-import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
-import { DesignerConfig } from "../designer/designerConfig";
-import { DataScope, LegendBlockModel } from "./model";
-import { ModelInstance } from "./modelInstance/modelInstance";
+import { MdtChartsConfig, MdtChartsDataSource } from "../../config/config";
+import { DesignerConfig } from "../../designer/designerConfig";
+import { LegendBlockModel } from "../model";
+import { ModelInstance } from "../modelInstance/modelInstance";
+export interface DataLegendParams {
+    amount: number;
+    size: {
+        width: number;
+        height: number;
+    };
+}
 export declare class DataManagerModel {
+    private static service;
     static getPreparedData(data: MdtChartsDataSource, allowableKeys: string[], config: MdtChartsConfig): MdtChartsDataSource;
-    static getDataScope(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig, legendBlock: LegendBlockModel, modelInstance: ModelInstance): DataScope;
+    static initDataScope(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig, legendBlock: LegendBlockModel, modelInstance: ModelInstance): void;
     static getDataValuesByKeyField(data: MdtChartsDataSource, dataSourceName: string, keyFieldName: string): string[];
-    private static getDataScopeFor2D;
-    private static getDataScopeForPolar;
+    private static initDataScopeFor2D;
+    private static initDataScopeForPolar;
+    private static getLegendDataParams;
+    private static getMaximumPossibleScope;
+    private static limitAllowableKeys;
     /**
      * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
      * @param configOptions