mdt-charts 1.12.0 → 1.12.1

package/lib/model/featuresModel/legendModel/legendModel.js

@@ -5,11 +5,12 @@ export class LegendModel {
     static getLegendSize(chartNotation, position, texts, legendMaxWidth, blockSize, legendBlockModel) {
         if (position === 'left' || position === 'right')
             return this.getLegendWidth(texts, legendMaxWidth);
+        //TODO: rm duplicate
         if (chartNotation === '2d' || chartNotation === 'interval') {
-            return LegendCanvasModel.getLegendHeight(texts, blockSize.width, legendBlockModel.coordinate[position].margin.left, legendBlockModel.coordinate[position].margin.right, 'row', position);
+            return LegendCanvasModel.getLegendHeight(texts, blockSize.width - legendBlockModel.coordinate[position].margin.left - legendBlockModel.coordinate[position].margin.right, 'row', position);
         }
         else if (chartNotation === 'polar') {
-            const size = LegendCanvasModel.getLegendHeight(texts, blockSize.width, legendBlockModel.coordinate[position].margin.left, legendBlockModel.coordinate[position].margin.right, 'column', position);
+            const size = LegendCanvasModel.getLegendHeight(texts, blockSize.width - legendBlockModel.coordinate[position].margin.left - legendBlockModel.coordinate[position].margin.right, 'row', position);
             return size;
         }
     }
@@ -24,17 +25,17 @@ export class LegendModel {
                 },
                 bottom: {
                     size: 0,
-                    margin: { top: 0, bottom: 20, left: 20, right: 20 },
+                    margin: { top: 0, bottom: 20, left: 0, right: 0 },
                     pad: 0
                 },
                 right: {
                     size: 0,
-                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 0, right: mr },
+                    margin: { top: canvasModel.titleCanvas.getAllNeededSpace(), bottom: mb, left: 10, right: 0 },
                     pad: 0
                 },
                 top: {
                     size: 0,
-                    margin: { top: 20, bottom: 0, left: 20, right: 20 },
+                    margin: { top: 10, bottom: 10, left: 20, right: 20 },
                     pad: canvasModel.titleCanvas.getAllNeededSpace()
                 }
             },
@@ -42,13 +43,15 @@ export class LegendModel {
         };
     }
     static getLegendModel(chartNotation, legendShow, canvasModel) {
+        if (!legendShow)
+            return {
+                position: 'off'
+            };
         let legendPosition = 'off';
-        if (legendShow) {
-            if (chartNotation === '2d' || chartNotation === 'interval')
-                legendPosition = 'top';
-            else if (chartNotation === 'polar') {
-                legendPosition = PolarModel.getLegendPositionByBlockSize(canvasModel);
-            }
+        if (chartNotation === '2d' || chartNotation === 'interval')
+            legendPosition = 'top';
+        else if (chartNotation === 'polar') {
+            legendPosition = PolarModel.getLegendPositionByBlockSize(canvasModel);
         }
         return {
             position: legendPosition
@@ -57,9 +60,6 @@ export class LegendModel {
     static getLegendItemClass(itemsPosition) {
         return itemsPosition === 'column' ? 'legend-item-row' : 'legend-item-inline';
     }
-    static getMarginClass(legendPosition) {
-        return legendPosition === 'right' ? 'mt-15' : 'mt-10';
-    }
     static getLegendWidth(texts, legendMaxWidth) {
         let longestText = '';
         let biggestScore = 0;

package/lib/model/featuresModel/legendModel/polarMarginCalculator.d.ts

@@ -0,0 +1,11 @@
+import { MdtChartsDataSource, MdtChartsPolarOptions } from "../../../config/config";
+import { LegendBlockModel } from "../../model";
+import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
+import { ModelInstance } from "../../modelInstance/modelInstance";
+export declare class LegendPolarMarginCalculator {
+    recalcMargin(modelInstance: ModelInstance, options: MdtChartsPolarOptions, legendMaxWidth: number, legendBlockModel: LegendBlockModel, data: MdtChartsDataSource): void;
+    updateMargin(legendPosition: "right" | "bottom", canvasModel: CanvasModel, legendBlockModel: LegendBlockModel, size: number): void;
+    private updateMarginObj;
+    private getLegendSize;
+    private getLegendItemsContent;
+}

package/lib/model/featuresModel/legendModel/polarMarginCalculator.js

@@ -0,0 +1,42 @@
+import { DataManagerModel } from "../../dataManagerModel/dataManagerModel";
+import { MarginModel } from "../../marginModel";
+import { MIN_DONUT_BLOCK_SIZE } from "../../notations/polarModel";
+import { LegendModel } from "./legendModel";
+export class LegendPolarMarginCalculator {
+    recalcMargin(modelInstance, options, legendMaxWidth, legendBlockModel, data) {
+        const canvasModel = modelInstance.canvasModel;
+        let legendPosition = LegendModel.getLegendModel(options.type, options.legend.show, modelInstance.canvasModel).position;
+        modelInstance.canvasModel.legendCanvas.setPosition(legendPosition);
+        if (legendPosition === "off")
+            return;
+        let legendSize = this.getLegendSize(options, legendMaxWidth, legendBlockModel, data, canvasModel, legendPosition);
+        if (legendPosition === "right" && canvasModel.getChartBlockWidth() - legendSize < MIN_DONUT_BLOCK_SIZE) {
+            legendSize = this.getLegendSize(options, legendMaxWidth, legendBlockModel, data, canvasModel, "bottom");
+            legendPosition = "bottom";
+            modelInstance.canvasModel.legendCanvas.setPosition(legendPosition);
+        }
+        if (legendSize !== 0) {
+            canvasModel.increaseMarginSide(legendPosition, legendSize);
+            MarginModel.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
+        }
+        legendBlockModel.coordinate[legendPosition].size = legendSize;
+    }
+    updateMargin(legendPosition, canvasModel, legendBlockModel, size) {
+        canvasModel.legendCanvas.setPosition(legendPosition);
+        this.updateMarginObj(legendBlockModel, legendPosition, size, canvasModel);
+    }
+    updateMarginObj(legendBlockModel, legendPosition, legendSize, canvasModel) {
+        if (legendSize !== 0) {
+            canvasModel.increaseMarginSide(legendPosition, legendSize);
+            MarginModel.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
+        }
+        legendBlockModel.coordinate[legendPosition].size = legendSize;
+    }
+    getLegendSize(options, legendMaxWidth, legendBlockModel, data, canvasModel, legendPosition) {
+        const legendItemsContent = this.getLegendItemsContent(options, data);
+        return LegendModel.getLegendSize(options.type, legendPosition, legendItemsContent, legendMaxWidth, canvasModel.getBlockSize(), legendBlockModel);
+    }
+    getLegendItemsContent(options, data) {
+        return DataManagerModel.getDataValuesByKeyField(data, options.data.dataSource, options.data.keyField.name);
+    }
+}

package/lib/model/featuresModel/titleModel.js

@@ -4,7 +4,7 @@ export class TitleModel {
         const pad = titleText ? defaultPads : 0;
         return {
             margin: {
-                bottom: 0,
+                bottom: 10,
                 left: pad,
                 right: pad,
                 top: pad

package/lib/model/marginModel.d.ts

@@ -1,7 +1,8 @@
 import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
 import { DesignerConfig } from "../designer/designerConfig";
-import { DataScope, LegendBlockModel, OtherCommonComponents, PolarOptionsModel } from "./model";
+import { DataScope, LegendBlockModel, Orient, OtherCommonComponents, PolarOptionsModel } from "./model";
 import { ModelInstance } from "./modelInstance/modelInstance";
+import { CanvasModel } from "./modelInstance/canvasModel/canvasModel";
 export declare const AXIS_HORIZONTAL_LABEL_PADDING = 15;
 export declare const AXIS_VERTICAL_LABEL_PADDING = 10;
 export declare class MarginModel {
@@ -13,7 +14,7 @@ export declare class MarginModel {
     private static recalcHorizontalMarginByAxisLabelWidth;
     private static recalcMarginWithLegend;
     private static getLegendItemsContent;
-    private static appendToGlobalMarginValuesLegendMargin;
+    static appendToGlobalMarginValuesLegendMargin(canvasModel: CanvasModel, position: Orient, legendBlockModel: LegendBlockModel): void;
     private static clearMarginByLegendBlockPosition;
     private static recalcMarginByTitle;
 }

package/lib/model/marginModel.js

@@ -42,7 +42,7 @@ export class MarginModel {
     static recalcMarginByVerticalAxisLabel(modelInstance, config, designerConfig, dataScope) {
         if ((config.options.type === '2d' || config.options.type === 'interval') && config.options.orientation === 'vertical') {
             const axisLabelSize = AxisModel.getLabelSize(designerConfig.canvas.axisLabel.maxSize.main, dataScope.allowableKeys);
-            const axisConfig = AxisModel.getKeyAxisLabelPosition(modelInstance.canvasModel, dataScope.allowableKeys.length);
+            const axisConfig = AxisModel.getKeyAxisLabelPosition(modelInstance.canvasModel, dataScope.allowableKeys.length, config.options.axis.key);
             const marginOrient = config.options.axis.key.position === 'end' ? 'bottom' : 'top';
             if (axisConfig === 'rotated')
                 modelInstance.canvasModel.setMarginSide(marginOrient, modelInstance.canvasModel.getMarginSide(marginOrient) + (axisLabelSize.width - axisLabelSize.height));
@@ -80,6 +80,9 @@ export class MarginModel {
         }
     }
     static recalcMarginWithLegend(modelInstance, config, legendMaxWidth, legendBlockModel, data) {
+        if (config.options.type === "polar") {
+            return;
+        }
         const canvasModel = modelInstance.canvasModel;
         const legendPosition = LegendModel.getLegendModel(config.options.type, config.options.legend.show, modelInstance.canvasModel).position;
         modelInstance.canvasModel.legendCanvas.setPosition(legendPosition);
@@ -124,6 +127,6 @@ export class MarginModel {
         });
     }
     static recalcMarginByTitle(canvasModel, titleBlockModel) {
-        canvasModel.increaseMarginSide("top", titleBlockModel.margin.top + titleBlockModel.size);
+        canvasModel.increaseMarginSide("top", titleBlockModel.margin.top + titleBlockModel.size + titleBlockModel.margin.bottom);
     }
 }

package/lib/model/model.d.ts

@@ -1,10 +1,9 @@
-import { ChartOrientation, MdtChartsColorField, IntervalChartType, PolarChartType, Size, TooltipOptions, TwoDimensionalChartType } from "../config/config";
+import { ChartOrientation, MdtChartsColorField, IntervalChartType, PolarChartType, Size, TooltipOptions, TwoDimensionalChartType, AxisLabelPosition } from "../config/config";
 import { DataType, DonutOptionsCanvas, Formatter, TooltipSettings, Transitions } from "../designer/designerConfig";
 declare type AxisType = "key" | "value";
 export declare type Orient = "top" | "bottom" | "left" | "right";
 export declare type ScaleKeyType = "band" | "point";
 export declare type ScaleValueType = "linear" | "datetime";
-export declare type AxisLabelPosition = "straight" | "rotated";
 export declare type LegendPosition = "off" | "top" | "bottom" | "left" | "right";
 export declare type EmbeddedLabelTypeModel = "none" | "key" | "value";
 export declare type DataOptions = {

package/lib/model/modelBuilder.js

@@ -78,8 +78,8 @@ export function assembleModel(config, data, designerConfig) {
     const options = getOptions(config, designerConfig, modelInstance, modelInstance.dataModel.getScope(), preparedData);
     const dataSettings = getDataSettings(modelInstance.dataModel.getScope(), designerConfig);
     const transitions = getTransitions(designerConfig);
-    if (options.type === 'polar')
-        MarginModel.recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, otherComponents.legendBlock, modelInstance.dataModel.getScope(), options);
+    // if (options.type === 'polar')
+    //     MarginModel.recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, otherComponents.legendBlock, modelInstance.dataModel.getScope(), options);
     modelInstance.canvasModel.roundMargin();
     return {
         blockCanvas,

package/lib/model/notations/polarModel.d.ts

@@ -1,6 +1,6 @@
 import { MdtChartsDataSource, MdtChartsPolarOptions } from "../../config/config";
 import { DesignerConfig } from "../../designer/designerConfig";
-import { PolarOptionsModel } from "../model";
+import { PolarOptionsModel, LegendCoordinate } from "../model";
 import { CanvasModel } from "../modelInstance/canvasModel/canvasModel";
 import { ModelInstance } from "../modelInstance/modelInstance";
 /** If donut block has width less than this const, legend change postion from "right" to "bottom" */
@@ -8,6 +8,8 @@ export declare const MIN_DONUT_BLOCK_SIZE = 120;
 export declare class PolarModel {
     static getOptions(options: MdtChartsPolarOptions, data: MdtChartsDataSource, designerConfig: DesignerConfig, modelInstance: ModelInstance): PolarOptionsModel;
     static getLegendPositionByBlockSize(canvasModel: CanvasModel): "bottom" | "right";
+    static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth: number, legendWidth: number, legendCoordinate: LegendCoordinate): boolean;
+    static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight: number, legendCoordinate: LegendCoordinate): boolean;
     private static getDonutSettings;
     private static getChartsModel;
 }

package/lib/model/notations/polarModel.js

@@ -17,13 +17,24 @@ export class PolarModel {
     //TODO: type for returned value
     static getLegendPositionByBlockSize(canvasModel) {
         const widthCoefficientWhenLegendShouldInBottom = 1.5;
+        const avgLegendWidth = 100;
         const blockWidth = canvasModel.getBlockSize().width;
         const blockHeight = canvasModel.getBlockSize().height;
-        return canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE
+        return canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE + avgLegendWidth
             && blockWidth * widthCoefficientWhenLegendShouldInBottom < blockHeight
             ? 'bottom'
             : 'right';
     }
+    static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth, legendWidth, legendCoordinate) {
+        const rightLegendMargin = legendCoordinate.right.margin;
+        return chartBlockWidth - legendWidth - rightLegendMargin.left - rightLegendMargin.right >= MIN_DONUT_BLOCK_SIZE;
+    }
+    static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight, legendCoordinate) {
+        const minHeightForLegend = 30;
+        const bottomLegendMargin = legendCoordinate.bottom.margin;
+        const heightForLegend = chartBlockHeight - bottomLegendMargin.bottom - bottomLegendMargin.top - MIN_DONUT_BLOCK_SIZE;
+        return heightForLegend >= minHeightForLegend;
+    }
     static getDonutSettings(settings, chartOptions) {
         return {
             padAngle: settings.padAngle,

package/lib/model/notations/twoDimensionalModel.js

@@ -15,7 +15,7 @@ export class TwoDimensionalModel {
                 value: ScaleModel.getScaleLinear(options, data, canvasModel)
             },
             axis: {
-                key: AxisModel.getKeyAxis(options.charts, data, options.data, options.orientation, options.axis.key, designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip),
+                key: AxisModel.getKeyAxis(options, data, designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip),
                 value: AxisModel.getValueAxis(options.orientation, options.axis.value, designerConfig.canvas.axisLabel, canvasModel)
             },
             type: options.type,

package/lib/style/charts-main.css

@@ -1,3 +1,5 @@
+@import url('https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap');
+
 .wrapper {
     margin: 0 auto;
     position: relative;
@@ -41,28 +43,45 @@
 
 
 /*========================================================================== Legend */
+.legend-block {
+    display: flex;
+    height: 100%;
+}
+.legend-block-column {
+    flex-direction: column;
+}
+.legend-block-row {
+    flex-direction: row;
+    flex-wrap: wrap;
+}
+.legend-block-centered {
+    justify-content: center;
+}
 .legend-item {
     cursor: default;
     transition: opacity 0.1s;
+    /* will-change: opacity;      */
+}
+.legend-block-column .legend-item:not(:first-of-type) {
+    margin-top: 15px;
 }
 .legend-item-inline {
     white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
 }
-.legend-item-inline:not(:first-of-type) {
+.legend-wrapper-without-wrap .legend-item-inline:not(:first-of-type) {
     margin-left: 20px;
 }
+.legend-wrapper-with-wrap .legend-item-inline {
+    margin: 5px;
+}
 .legend-item-row {
     display: flex;
 }
 .legend-item-row > span {
     display: block;
 }
-.mt-15 {
-    margin-top: 15px;
-}
-.mt-10 {
-    margin-top: 10px;
-}
 
 .legend-label {
     font-size: 12px;

package/lib/style/charts-main.less

@@ -1,3 +1,5 @@
+@import url('https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap');
+
 .wrapper {
     margin: 0 auto;
     position: relative;
@@ -41,28 +43,45 @@
 
 
 /*========================================================================== Legend */
+.legend-block {
+    display: flex;
+    height: 100%;
+}
+.legend-block-column {
+    flex-direction: column;
+}
+.legend-block-row {
+    flex-direction: row;
+    flex-wrap: wrap;
+}
+.legend-block-centered {
+    justify-content: center;
+}
 .legend-item {
     cursor: default;
     transition: opacity 0.1s;
+    /* will-change: opacity;      */
+}
+.legend-block-column .legend-item:not(:first-of-type) {
+    margin-top: 15px;
 }
 .legend-item-inline {
     white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
 }
-.legend-item-inline:not(:first-of-type) {
+.legend-wrapper-without-wrap .legend-item-inline:not(:first-of-type) {
     margin-left: 20px;
 }
+.legend-wrapper-with-wrap .legend-item-inline {
+    margin: 5px;
+}
 .legend-item-row {
     display: flex;
 }
 .legend-item-row > span {
     display: block;
 }
-.mt-15 {
-    margin-top: 15px;
-}
-.mt-10 {
-    margin-top: 10px;
-}
 
 .legend-label {
     font-size: 12px;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdt-charts",
-  "version": "1.12.0",
+  "version": "1.12.1",
   "description": "",
   "main": "lib/main.js",
   "scripts": {
@@ -8,7 +8,7 @@
     "build": "npx webpack --mode production",
     "watch": "npx webpack --mode development --watch",
     "test": "jest",
-    "build-lib": "npx tsc -p ."
+    "build-lib": "npx tsc -p tsconfig.production.json"
   },
   "homepage": "https://github.com/VishulaKnow/charts",
   "author": "",

package/tsconfig.production.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "outDir": "./lib/",
+        "noImplicitAny": true,
+        "target": "es6",
+        "lib": ["ES2017", "DOM"],
+        "jsx": "react",
+        "allowJs": true,
+        "types": [
+            "jest"
+        ],
+        "declaration": true
+    },
+    "include": [
+        "src"
+    ],
+    "exclude": [
+        "node_modules",
+        "**/__tests__/*",
+        "src/playground/*",
+        "**/*Example.ts"
+    ]
+}

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

@@ -1,14 +0,0 @@
-import { ChartOrientation } from "../../../config/config";
-import { Block } from "../../block/block";
-declare type AlertBlockPosition = 'top' | 'bottom' | 'right' | 'left';
-export declare class RecordOverflowAlert {
-    private static readonly blockClass;
-    static render(block: Block, hidedRecordsAmount: number, position: AlertBlockPosition, chartOrientation?: ChartOrientation): void;
-    static update(block: Block, hidedRecordsAmount: number, position: AlertBlockPosition, chartOrientation?: ChartOrientation): void;
-    private static setAlertPosition;
-    private static getAlertText;
-    private static getWordTextEndingByAmount;
-    private static getBlockPositionAttrs;
-    private static getLeftAttrForRightBlock;
-}
-export {};

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

@@ -1,97 +0,0 @@
-import { DomHelper } from '../../helpers/domHelper';
-import { Legend } from '../legend/legend';
-export class RecordOverflowAlert {
-    static render(block, hidedRecordsAmount, position, chartOrientation = null) {
-        const alertBlock = block.getWrapper()
-            .append('div')
-            .attr('class', this.blockClass)
-            .text(this.getAlertText(hidedRecordsAmount, chartOrientation));
-        const attrs = this.getBlockPositionAttrs(position, block);
-        this.setAlertPosition(alertBlock, attrs);
-    }
-    static update(block, hidedRecordsAmount, position, chartOrientation = null) {
-        let alertBlock = block.getWrapper()
-            .select(`div.${this.blockClass}`);
-        if (alertBlock.empty()) {
-            if (hidedRecordsAmount === 0)
-                return;
-            else
-                this.render(block, hidedRecordsAmount, position, chartOrientation);
-        }
-        else {
-            if (hidedRecordsAmount === 0)
-                alertBlock.remove();
-            else
-                alertBlock.text(this.getAlertText(hidedRecordsAmount, chartOrientation));
-        }
-    }
-    static setAlertPosition(alertBlock, attrs) {
-        alertBlock
-            .style('position', 'absolute')
-            .style('left', attrs.left)
-            .style('right', attrs.right)
-            .style('top', attrs.top)
-            .style('bottom', attrs.bottom);
-    }
-    static getAlertText(hidedRecordsAmount, chartOrientation) {
-        return `+ ${hidedRecordsAmount} ${this.getWordTextEndingByAmount(hidedRecordsAmount, chartOrientation)}`;
-    }
-    static getWordTextEndingByAmount(hidedRecordsAmount, chartOrientation) {
-        const lastDigit = hidedRecordsAmount % 10;
-        if (chartOrientation === 'vertical') {
-            if (hidedRecordsAmount >= 10 && hidedRecordsAmount <= 20)
-                return 'столбцов';
-            if (lastDigit === 1)
-                return 'столбец';
-            if (lastDigit >= 2 && lastDigit <= 4)
-                return 'столбца';
-            return 'столбцов';
-        }
-        else if (chartOrientation === 'horizontal') {
-            if (hidedRecordsAmount >= 10 && hidedRecordsAmount <= 20)
-                return 'строк';
-            if (lastDigit === 1)
-                return 'строка';
-            if (lastDigit >= 2 && lastDigit <= 4)
-                return 'строки';
-            return 'строк';
-        }
-        else {
-            if (hidedRecordsAmount >= 10 && hidedRecordsAmount <= 20)
-                return 'категорий';
-            if (lastDigit === 1)
-                return 'категория';
-            if (lastDigit >= 2 && lastDigit <= 4)
-                return 'категории';
-            return 'категорий';
-        }
-    }
-    static getBlockPositionAttrs(position, block) {
-        const attrs = {
-            bottom: null,
-            top: null,
-            right: null,
-            left: null
-        };
-        if (position === 'top') {
-            attrs.right = '17px';
-            attrs.top = '1rem';
-        }
-        if (position === 'right') {
-            attrs.bottom = '20px';
-            attrs.left = this.getLeftAttrForRightBlock(block) + 'px';
-        }
-        if (position === 'bottom') {
-            attrs.left = '20px';
-            attrs.bottom = '20px';
-        }
-        return attrs;
-    }
-    static getLeftAttrForRightBlock(block) {
-        const legendBlock = block.getSvg().select(`.${Legend.objectClass}`);
-        if (legendBlock.empty())
-            return null;
-        return DomHelper.getSelectionNumericAttr(legendBlock, 'x');
-    }
-}
-RecordOverflowAlert.blockClass = 'record-overflow-alert';

package/lib/model/dataManagerModel.d.ts

@@ -1,23 +0,0 @@
-import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
-import { DesignerConfig } from "../designer/designerConfig";
-import { DataScope, LegendBlockModel } from "./model";
-import { ModelInstance } from "./modelInstance/modelInstance";
-export declare class DataManagerModel {
-    static getPreparedData(data: MdtChartsDataSource, allowableKeys: string[], config: MdtChartsConfig): MdtChartsDataSource;
-    static getDataScope(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig, legendBlock: LegendBlockModel, modelInstance: ModelInstance): DataScope;
-    static getDataValuesByKeyField(data: MdtChartsDataSource, dataSourceName: string, keyFieldName: string): string[];
-    private static getDataScopeFor2D;
-    private static getDataScopeForPolar;
-    /**
-     * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
-     * @param configOptions
-     * @param chartsLength
-     */
-    private static getElementsInGroupAmount;
-    private static getBarChartsInGroupAmount;
-    private static getScopedData;
-    private static getScopedChartData;
-    private static setDataType;
-    private static getTypedData;
-    private static getDataLimitByItemSize;
-}