mdt-charts 1.11.1 → 1.12.0

package/lib/config/config.d.ts

@@ -61,6 +61,7 @@ export interface Legend {
 export interface DataOptions {
     dataSource: string;
     keyField: MdtChartsField;
+    maxRecordsAmount?: number;
 }
 export interface MdtChartsField {
     name: string;

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,16 @@
+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;
+    private getLeftAttrForRightBlock;
+}
+export declare const PolarRecordOverflowAlert: PolarRecordOverflowAlertClass;
+export {};

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

@@ -0,0 +1,48 @@
+import { Legend } from "../../features/legend/legend";
+import { RecordOverflowAlertCore } from "../../features/recordOverflowAlert/recordOverflowAlertCore";
+import { DomHelper } from "../../helpers/domHelper";
+class PolarRecordOverflowAlertClass {
+    constructor() {
+        this.text = {
+            one: 'категория',
+            twoToFour: 'категории',
+            tenToTwenty: 'категорий',
+            other: 'категорий'
+        };
+    }
+    render(block, options) {
+        RecordOverflowAlertCore.render(block, this.buildCoreOptions(block, options));
+    }
+    update(block, options) {
+        RecordOverflowAlertCore.update(block, this.buildCoreOptions(block, options));
+    }
+    buildCoreOptions(block, options) {
+        return {
+            hidedRecordsAmount: options.hidedRecordsAmount,
+            text: this.text,
+            positionAttrs: this.getPositionAttrs(block, options)
+        };
+    }
+    getPositionAttrs(block, options) {
+        const position = options.legendPosition === 'off' ? 'bottom' : options.legendPosition;
+        if (position === 'right') {
+            return {
+                bottom: '20px',
+                left: this.getLeftAttrForRightBlock(block) + 'px'
+            };
+        }
+        if (position === 'bottom') {
+            return {
+                bottom: '20px',
+                left: '20px'
+            };
+        }
+    }
+    getLeftAttrForRightBlock(block) {
+        const legendBlock = block.getSvg().select(`.${Legend.objectClass}`);
+        if (legendBlock.empty())
+            return 17;
+        return DomHelper.getSelectionNumericAttr(legendBlock, 'x');
+    }
+}
+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/dataManagerModel.d.ts

@@ -0,0 +1,26 @@
+import { MdtChartsConfig, MdtChartsDataSource } from "../../config/config";
+import { DesignerConfig } from "../../designer/designerConfig";
+import { LegendBlockModel } from "../model";
+import { ModelInstance } from "../modelInstance/modelInstance";
+export declare class DataManagerModel {
+    private static service;
+    static getPreparedData(data: MdtChartsDataSource, allowableKeys: string[], config: MdtChartsConfig): MdtChartsDataSource;
+    static initDataScope(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig, legendBlock: LegendBlockModel, modelInstance: ModelInstance): void;
+    static getDataValuesByKeyField(data: MdtChartsDataSource, dataSourceName: string, keyFieldName: string): string[];
+    private static initDataScopeFor2D;
+    private static initDataScopeForPolar;
+    private static getMaximumPossibleScope;
+    private static limitAllowableKeys;
+    /**
+     * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
+     * @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;
+}

package/lib/model/dataManagerModel/dataManagerModel.js

@@ -0,0 +1,132 @@
+import { AxisModel } from "../featuresModel/axisModel";
+import { LegendCanvasModel } from "../featuresModel/legendModel/legendCanvasModel";
+import { ModelHelper } from "../modelHelper";
+import { MIN_DONUT_BLOCK_SIZE, PolarModel } from "../notations/polarModel";
+import { DataManagerModelService } from "./dataManagerModelService";
+export class DataManagerModel {
+    static getPreparedData(data, allowableKeys, config) {
+        const scopedData = this.getScopedData(data, allowableKeys, config);
+        this.setDataType(scopedData, config);
+        return scopedData;
+    }
+    static initDataScope(config, data, designerConfig, legendBlock, modelInstance) {
+        if (config.options.type === '2d' || config.options.type === 'interval') {
+            this.initDataScopeFor2D(config.options, modelInstance, data, designerConfig);
+        }
+        else if (config.options.type === 'polar') {
+            this.initDataScopeForPolar(config.options, modelInstance, data, legendBlock, designerConfig.canvas.legendBlock);
+        }
+    }
+    static getDataValuesByKeyField(data, dataSourceName, keyFieldName) {
+        return data[dataSourceName].map(dataRow => dataRow[keyFieldName]);
+    }
+    static initDataScopeFor2D(configOptions, modelInstance, data, designerConfig) {
+        // Для interval всегда один элемент, так как там может быть только один столбик
+        let itemsLength = 1;
+        if (configOptions.type === '2d') {
+            itemsLength = (configOptions.charts)
+                .filter((chart) => chart.type === 'bar').length;
+            if (itemsLength === 0)
+                itemsLength = 1; // Если баров нет, то для одной записи выделяется столько же места, сколько для одного столбика
+        }
+        if (itemsLength !== 0) {
+            const axisLength = AxisModel.getAxisLength(configOptions.orientation, modelInstance.canvasModel);
+            const uniqueKeys = ModelHelper.getUniqueValues(data[configOptions.data.dataSource].map(d => d[configOptions.data.keyField.name]));
+            const dataLength = uniqueKeys.length;
+            const limit = this.getDataLimitByItemSize(this.getElementsInGroupAmount(configOptions, itemsLength), dataLength, axisLength, designerConfig.canvas.chartOptions.bar);
+            const allowableKeys = uniqueKeys.slice(0, limit);
+            const hidedRecordsAmount = dataLength - allowableKeys.length;
+            modelInstance.dataModel.initScope(this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel));
+        }
+        else {
+            const allKeys = this.getDataValuesByKeyField(data, configOptions.data.dataSource, configOptions.data.keyField.name);
+            modelInstance.dataModel.initScope(this.getMaximumPossibleScope(allKeys, modelInstance.dataModel));
+        }
+    }
+    static initDataScopeForPolar(configOptions, modelInstance, data, legendBlock, legendCanvas) {
+        const canvas = modelInstance.canvasModel;
+        const dataset = data[configOptions.data.dataSource];
+        const keyFieldName = configOptions.data.keyField.name;
+        const keys = dataset.map(dataRow => dataRow[keyFieldName]);
+        if (!configOptions.legend.show) {
+            modelInstance.dataModel.initScope(this.getMaximumPossibleScope(keys, modelInstance.dataModel));
+            return;
+        }
+        const position = PolarModel.getLegendPositionByBlockSize(modelInstance.canvasModel);
+        let maxItemsNumber;
+        if (position === 'right') {
+            maxItemsNumber = LegendCanvasModel.findElementsAmountByLegendSize(keys, position, legendCanvas.maxWidth, canvas.getChartBlockHeight());
+        }
+        else {
+            const margin = canvas.getMargin();
+            const marginBottomWithoutLegendBlock = margin.bottom - (legendBlock.coordinate.bottom.size === 0 ? legendBlock.coordinate.bottom.size : legendBlock.coordinate.bottom.size - legendBlock.coordinate.bottom.margin.bottom);
+            maxItemsNumber = LegendCanvasModel.findElementsAmountByLegendSize(keys, position, canvas.getChartBlockWidth(), canvas.getBlockSize().height - margin.top - marginBottomWithoutLegendBlock - legendBlock.coordinate.bottom.margin.bottom - MIN_DONUT_BLOCK_SIZE);
+        }
+        const allowableKeys = keys.slice(0, maxItemsNumber);
+        const hidedRecordsAmount = keys.length - maxItemsNumber;
+        modelInstance.dataModel.initScope(this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel));
+    }
+    static getMaximumPossibleScope(keys, dataModel) {
+        return this.service.getMaximumPossibleAmount(keys, dataModel.getMaxRecordsAmount());
+    }
+    static limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel) {
+        return this.service.limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel.getMaxRecordsAmount());
+    }
+    /**
+     * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
+     * @param configOptions
+     * @param chartsLength
+     */
+    static getElementsInGroupAmount(configOptions, chartsLength) {
+        if (configOptions.type === '2d')
+            return this.getBarChartsInGroupAmount(configOptions.charts);
+        return chartsLength;
+    }
+    static getBarChartsInGroupAmount(charts) {
+        let barsAmount = 0;
+        charts.forEach(chart => {
+            if (chart.type === 'bar' && chart.isSegmented)
+                barsAmount += 1; // в сегментированном баре все valueFields находятся внутри одного бара, поэтому бар всегда один.
+            else if (chart.type === 'bar')
+                barsAmount += chart.data.valueFields.length;
+        });
+        return barsAmount;
+    }
+    static getScopedData(data, allowableKeys, config) {
+        const newData = {};
+        newData[config.options.data.dataSource] = this.getScopedChartData(data[config.options.data.dataSource], allowableKeys, config.options.data.keyField.name);
+        return newData;
+    }
+    static getScopedChartData(data, allowableKeys, keyFieldName) {
+        return data.filter(d => allowableKeys.findIndex(key => key === d[keyFieldName]) !== -1);
+    }
+    static setDataType(data, config) {
+        if (config.options.type === 'interval') {
+            const chart = config.options.chart;
+            if (chart.data.valueField1.format === 'date') {
+                data[config.options.data.dataSource] = this.getTypedData(data[config.options.data.dataSource], chart.data.valueField1);
+            }
+            if (chart.data.valueField2.format === 'date') {
+                data[config.options.data.dataSource] = this.getTypedData(data[config.options.data.dataSource], chart.data.valueField2);
+            }
+        }
+    }
+    static getTypedData(data, field) {
+        if (field.format === 'date')
+            data.forEach(d => {
+                d[field.name] = new Date(d[field.name]);
+            });
+        return data;
+    }
+    static getDataLimitByItemSize(elementsInGroupAmount, dataLength, axisLength, barOptions) {
+        let sumSize = dataLength * (elementsInGroupAmount * barOptions.minBarWidth + (elementsInGroupAmount - 1) * barOptions.barDistance + barOptions.groupMinDistance);
+        while (dataLength !== 0 && axisLength < sumSize) {
+            dataLength--;
+            // find whole space for bars in group + distance between bars + group distance
+            sumSize = dataLength * (elementsInGroupAmount * barOptions.minBarWidth + (elementsInGroupAmount - 1)
+                * barOptions.barDistance + barOptions.groupMinDistance);
+        }
+        return dataLength;
+    }
+}
+DataManagerModel.service = new DataManagerModelService();

package/lib/model/dataManagerModel/dataManagerModelService.d.ts

@@ -0,0 +1,5 @@
+import { DataScope } from "../model";
+export declare class DataManagerModelService {
+    getMaximumPossibleAmount(keys: string[], maxPossibleAmount: number): DataScope;
+    limitAllowableKeys(allowableKeys: string[], hidedRecordsAmount: number, globalRecordsMaxAmount: number): DataScope;
+}

package/lib/model/dataManagerModel/dataManagerModelService.js

@@ -0,0 +1,28 @@
+export class DataManagerModelService {
+    getMaximumPossibleAmount(keys, maxPossibleAmount) {
+        if (maxPossibleAmount >= keys.length) {
+            return {
+                allowableKeys: keys,
+                hidedRecordsAmount: 0
+            };
+        }
+        else {
+            return {
+                allowableKeys: keys.slice(0, maxPossibleAmount),
+                hidedRecordsAmount: keys.length - maxPossibleAmount
+            };
+        }
+    }
+    limitAllowableKeys(allowableKeys, hidedRecordsAmount, globalRecordsMaxAmount) {
+        if (allowableKeys.length <= globalRecordsMaxAmount) {
+            return {
+                allowableKeys,
+                hidedRecordsAmount
+            };
+        }
+        return {
+            allowableKeys: allowableKeys.slice(0, globalRecordsMaxAmount),
+            hidedRecordsAmount: hidedRecordsAmount + allowableKeys.length - globalRecordsMaxAmount
+        };
+    }
+}

package/lib/model/featuresModel/axisModel.js

@@ -1,6 +1,6 @@
 import { ModelHelper } from "../modelHelper";
 import { AxisType, CLASSES } from "../modelBuilder";
-import { DataManagerModel } from "../dataManagerModel";
+import { DataManagerModel } from "../dataManagerModel/dataManagerModel";
 import { TwoDimensionalModel } from "../notations/twoDimensionalModel";
 export class AxisModel {
     static getKeyAxis(charts, data, dataOptions, orient, axisConfig, labelConfig, canvasModel, tooltipSettings) {

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

@@ -2,8 +2,6 @@ import { ChartNotation, Size } from "../../../config/config";
 import { ILegendModel, LegendBlockModel, LegendPosition, Orient } from "../../model";
 import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
 import { LegendItemsDirection } from "./legendCanvasModel";
-/** If donut block has width less than this const, legend change postion from "right" to "bottom" */
-export declare const MIN_DONUT_BLOCK_SIZE = 260;
 export declare class LegendModel {
     static getLegendSize(chartNotation: ChartNotation, position: Orient, texts: string[], legendMaxWidth: number, blockSize: Size, legendBlockModel: LegendBlockModel): number;
     static getBaseLegendBlockModel(notation: ChartNotation, canvasModel: CanvasModel): LegendBlockModel;

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

@@ -1,7 +1,6 @@
 import { ModelHelper } from "../../modelHelper";
+import { PolarModel } from "../../notations/polarModel";
 import { LegendCanvasModel } from "./legendCanvasModel";
-/** If donut block has width less than this const, legend change postion from "right" to "bottom" */
-export const MIN_DONUT_BLOCK_SIZE = 260;
 export class LegendModel {
     static getLegendSize(chartNotation, position, texts, legendMaxWidth, blockSize, legendBlockModel) {
         if (position === 'left' || position === 'right')
@@ -48,7 +47,7 @@ export class LegendModel {
             if (chartNotation === '2d' || chartNotation === 'interval')
                 legendPosition = 'top';
             else if (chartNotation === 'polar') {
-                legendPosition = canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE ? 'bottom' : 'right';
+                legendPosition = PolarModel.getLegendPositionByBlockSize(canvasModel);
             }
         }
         return {

package/lib/model/marginModel.js

@@ -1,8 +1,9 @@
 import { AxisModel } from "./featuresModel/axisModel";
-import { DataManagerModel } from "./dataManagerModel";
-import { LegendModel, MIN_DONUT_BLOCK_SIZE } from "./featuresModel/legendModel/legendModel";
+import { DataManagerModel } from "./dataManagerModel/dataManagerModel";
+import { LegendModel } from "./featuresModel/legendModel/legendModel";
 import { AxisType } from "./modelBuilder";
 import { TwoDimensionalModel } from "./notations/twoDimensionalModel";
+import { PolarModel } from "./notations/polarModel";
 export const AXIS_HORIZONTAL_LABEL_PADDING = 15;
 export const AXIS_VERTICAL_LABEL_PADDING = 10;
 export class MarginModel {
@@ -25,10 +26,9 @@ export class MarginModel {
     }
     static recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, legendBlockModel, dataScope, options) {
         const canvasModel = modelInstance.canvasModel;
-        let position = LegendModel.getLegendModel(config.options.type, config.options.legend.show, modelInstance.canvasModel).position;
+        let position = canvasModel.legendCanvas.getPosition();
         if (position !== 'off') {
-            if (position === 'right' && canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE)
-                position = 'bottom';
+            position = PolarModel.getLegendPositionByBlockSize(canvasModel); // reset position
             this.clearMarginByLegendBlockPosition(canvasModel, legendBlockModel);
             let allowableKeys = [...dataScope.allowableKeys];
             if (dataScope.hidedRecordsAmount !== 0 && position === 'bottom')
@@ -82,6 +82,7 @@ export class MarginModel {
     static recalcMarginWithLegend(modelInstance, config, legendMaxWidth, legendBlockModel, data) {
         const canvasModel = modelInstance.canvasModel;
         const legendPosition = LegendModel.getLegendModel(config.options.type, config.options.legend.show, modelInstance.canvasModel).position;
+        modelInstance.canvasModel.legendCanvas.setPosition(legendPosition);
         if (legendPosition !== 'off') {
             const legendItemsContent = this.getLegendItemsContent(config.options, data);
             const legendSize = LegendModel.getLegendSize(config.options.type, legendPosition, legendItemsContent, legendMaxWidth, canvasModel.getBlockSize(), legendBlockModel);

package/lib/model/modelBuilder.js

@@ -1,7 +1,7 @@
 import { MarginModel } from './marginModel';
 import { TwoDimensionalModel } from './notations/twoDimensionalModel';
 import { PolarModel } from './notations/polarModel';
-import { DataManagerModel } from './dataManagerModel';
+import { DataManagerModel } from './dataManagerModel/dataManagerModel';
 import { IntervalModel } from './notations/intervalModel';
 import { OtherComponentsModel } from './featuresModel/otherComponents';
 import { ConfigValidator } from './configsValidator/configValidator';
@@ -69,17 +69,17 @@ export function assembleModel(config, data, designerConfig) {
     resetFalsyValues(data, config.options.data.keyField.name);
     const otherComponents = OtherComponentsModel.getOtherComponentsModel({ elementsOptions: designerConfig.elementsOptions, notation: config.options.type, title: config.options.title }, modelInstance);
     MarginModel.initMargin(designerConfig, config, otherComponents, data, modelInstance);
-    const dataScope = DataManagerModel.getDataScope(config, data, designerConfig, otherComponents.legendBlock, modelInstance);
-    const preparedData = DataManagerModel.getPreparedData(data, dataScope.allowableKeys, config);
+    DataManagerModel.initDataScope(config, data, designerConfig, otherComponents.legendBlock, modelInstance);
+    const preparedData = DataManagerModel.getPreparedData(data, modelInstance.dataModel.getAllowableKeys(), config);
     if (config.options.type === '2d' && config.options.axis.key.visibility)
-        MarginModel.recalcMarginByVerticalAxisLabel(modelInstance, config, designerConfig, dataScope);
+        MarginModel.recalcMarginByVerticalAxisLabel(modelInstance, config, designerConfig, modelInstance.dataModel.getScope());
     const blockCanvas = getBlockCanvas(config, modelInstance);
     const chartBlock = getChartBlockModel(modelInstance);
-    const options = getOptions(config, designerConfig, modelInstance, dataScope, preparedData);
-    const dataSettings = getDataSettings(dataScope, 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, dataScope, options);
+        MarginModel.recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, otherComponents.legendBlock, modelInstance.dataModel.getScope(), options);
     modelInstance.canvasModel.roundMargin();
     return {
         blockCanvas,

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

@@ -1,9 +1,11 @@
 import { Size } from "../../../config/config";
 import { BlockMargin } from "../../model";
+import { LegendCanvasModelInstance } from "./legendCanvasModel";
 import { TitleCanvasModel } from "./titleCanvas";
 declare type MarginSide = keyof BlockMargin;
 export declare class CanvasModel {
     titleCanvas: TitleCanvasModel;
+    legendCanvas: LegendCanvasModelInstance;
     private blockSize;
     private margin;
     constructor();

package/lib/model/modelInstance/canvasModel/canvasModel.js

@@ -1,7 +1,9 @@
+import { LegendCanvasModelInstance } from "./legendCanvasModel";
 import { TitleCanvasModel } from "./titleCanvas";
 export class CanvasModel {
     constructor() {
         this.titleCanvas = new TitleCanvasModel();
+        this.legendCanvas = new LegendCanvasModelInstance();
     }
     initMargin(margin) {
         this.margin = margin;

package/lib/model/modelInstance/canvasModel/legendCanvasModel.d.ts

@@ -0,0 +1,7 @@
+import { ILegendModel, LegendPosition } from "../../model";
+export declare class LegendCanvasModelInstance {
+    private position;
+    getModel(): ILegendModel;
+    getPosition(): LegendPosition;
+    setPosition(position: LegendPosition): void;
+}

package/lib/model/modelInstance/canvasModel/legendCanvasModel.js

@@ -0,0 +1,13 @@
+export class LegendCanvasModelInstance {
+    getModel() {
+        return {
+            position: this.position
+        };
+    }
+    getPosition() {
+        return this.position;
+    }
+    setPosition(position) {
+        this.position = position;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { DataScope } from "../model";
+export declare const DEFAULT_MAX_RECORDS_AMOUNT = 50;
+export declare class DataModelInstance {
+    private maxRecordsAmount;
+    private scope;
+    initMaxRecordsAmount(amount: number): void;
+    getMaxRecordsAmount(): number;
+    initScope(scope: DataScope): void;
+    getScope(): DataScope;
+    getAllowableKeys(): string[];
+}

package/lib/model/modelInstance/dataModel.js

@@ -0,0 +1,23 @@
+export const DEFAULT_MAX_RECORDS_AMOUNT = 50;
+export class DataModelInstance {
+    constructor() {
+        this.maxRecordsAmount = DEFAULT_MAX_RECORDS_AMOUNT;
+    }
+    initMaxRecordsAmount(amount) {
+        if (typeof amount === "number" && amount > 0) {
+            this.maxRecordsAmount = amount;
+        }
+    }
+    getMaxRecordsAmount() {
+        return this.maxRecordsAmount;
+    }
+    initScope(scope) {
+        this.scope = scope;
+    }
+    getScope() {
+        return this.scope;
+    }
+    getAllowableKeys() {
+        return this.getScope().allowableKeys;
+    }
+}

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

@@ -1,7 +1,10 @@
 import { MdtChartsConfig } from "../../main";
 import { CanvasModel } from "./canvasModel/canvasModel";
+import { DataModelInstance } from "./dataModel";
 export declare class ModelInstance {
     static create(config: MdtChartsConfig): ModelInstance;
+    private static initInitialParams;
     canvasModel: CanvasModel;
+    dataModel: DataModelInstance;
     constructor();
 }

package/lib/model/modelInstance/modelInstance.js

@@ -1,11 +1,17 @@
 import { CanvasModel } from "./canvasModel/canvasModel";
+import { DataModelInstance } from "./dataModel";
 export class ModelInstance {
     constructor() {
         this.canvasModel = new CanvasModel();
+        this.dataModel = new DataModelInstance();
     }
     static create(config) {
         const modelInstance = new ModelInstance();
-        modelInstance.canvasModel.initBlockSize(config.canvas.size);
+        this.initInitialParams(modelInstance, config);
         return modelInstance;
     }
+    static initInitialParams(modelInstance, config) {
+        modelInstance.canvasModel.initBlockSize(config.canvas.size);
+        modelInstance.dataModel.initMaxRecordsAmount(config.options.data.maxRecordsAmount);
+    }
 }

package/lib/model/notations/intervalModel.js

@@ -1,7 +1,6 @@
 import { AxisModel } from "../featuresModel/axisModel";
 import { ChartStyleModelService } from "../chartStyleModel/chartStyleModel";
-import { DataManagerModel } from "../dataManagerModel";
-import { LegendModel } from "../featuresModel/legendModel/legendModel";
+import { DataManagerModel } from "../dataManagerModel/dataManagerModel";
 import { AxisType } from "../modelBuilder";
 import { ScaleModel, ScaleType } from "../featuresModel/scaleModel";
 import { TwoDimensionalModel } from "./twoDimensionalModel";
@@ -10,7 +9,7 @@ export class IntervalModel {
         const options = config.options;
         const canvasModel = modelInstance.canvasModel;
         return {
-            legend: LegendModel.getLegendModel(config.options.type, config.options.legend.show, canvasModel),
+            legend: canvasModel.legendCanvas.getModel(),
             title: options.title,
             selectable: !!options.selectable,
             orient: options.orientation,

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

@@ -1,9 +1,13 @@
 import { MdtChartsDataSource, MdtChartsPolarOptions } from "../../config/config";
 import { DesignerConfig } from "../../designer/designerConfig";
 import { PolarOptionsModel } 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" */
+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";
     private static getDonutSettings;
     private static getChartsModel;
 }

package/lib/model/notations/polarModel.js

@@ -1,5 +1,6 @@
 import { ChartStyleModelService } from "../chartStyleModel/chartStyleModel";
-import { LegendModel } from "../featuresModel/legendModel/legendModel";
+/** If donut block has width less than this const, legend change postion from "right" to "bottom" */
+export const MIN_DONUT_BLOCK_SIZE = 120;
 export class PolarModel {
     static getOptions(options, data, designerConfig, modelInstance) {
         return {
@@ -8,11 +9,21 @@ export class PolarModel {
             title: options.title,
             data: Object.assign({}, options.data),
             charts: this.getChartsModel(options.chart, data[options.data.dataSource].length, designerConfig.chartStyle),
-            legend: LegendModel.getLegendModel(options.type, options.legend.show, modelInstance.canvasModel),
+            legend: modelInstance.canvasModel.legendCanvas.getModel(),
             tooltip: options.tooltip,
             chartCanvas: this.getDonutSettings(designerConfig.canvas.chartOptions.donut, options.chart)
         };
     }
+    //TODO: type for returned value
+    static getLegendPositionByBlockSize(canvasModel) {
+        const widthCoefficientWhenLegendShouldInBottom = 1.5;
+        const blockWidth = canvasModel.getBlockSize().width;
+        const blockHeight = canvasModel.getBlockSize().height;
+        return canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE
+            && blockWidth * widthCoefficientWhenLegendShouldInBottom < blockHeight
+            ? 'bottom'
+            : 'right';
+    }
     static getDonutSettings(settings, chartOptions) {
         return {
             padAngle: settings.padAngle,

package/lib/model/notations/twoDimensionalModel.js

@@ -1,13 +1,12 @@
 import { ChartStyleModelService } from "../chartStyleModel/chartStyleModel";
 import { TwoDimensionalChartStyleModel } from "../chartStyleModel/TwoDimensionalChartStyleModel";
 import { AxisModel } from "../featuresModel/axisModel";
-import { LegendModel } from "../featuresModel/legendModel/legendModel";
 import { ScaleModel } from "../featuresModel/scaleModel";
 export class TwoDimensionalModel {
     static getOptions(options, designerConfig, dataScope, data, modelInstance) {
         const canvasModel = modelInstance.canvasModel;
         return {
-            legend: LegendModel.getLegendModel(options.type, options.legend.show, canvasModel),
+            legend: canvasModel.legendCanvas.getModel(),
             title: options.title,
             selectable: !!options.selectable,
             orient: options.orientation,

package/package.json

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