mdt-charts 1.12.0 → 1.12.4

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;
-}

package/lib/model/dataManagerModel.js

@@ -1,139 +0,0 @@
-import { AxisModel } from "./featuresModel/axisModel";
-import { LegendCanvasModel } from "./featuresModel/legendModel/legendCanvasModel";
-import { MIN_DONUT_BLOCK_SIZE } from "./featuresModel/legendModel/legendModel";
-import { ModelHelper } from "./modelHelper";
-export class DataManagerModel {
-    static getPreparedData(data, allowableKeys, config) {
-        const scopedData = this.getScopedData(data, allowableKeys, config);
-        this.setDataType(scopedData, config);
-        return scopedData;
-    }
-    static getDataScope(config, data, designerConfig, legendBlock, modelInstance) {
-        if (config.options.type === '2d' || config.options.type === 'interval') {
-            return this.getDataScopeFor2D(config.options, modelInstance, data, designerConfig);
-        }
-        else if (config.options.type === 'polar') {
-            return this.getDataScopeForPolar(config.options, modelInstance, data, legendBlock, designerConfig.canvas.legendBlock);
-        }
-    }
-    static getDataValuesByKeyField(data, dataSourceName, keyFieldName) {
-        return data[dataSourceName].map(dataRow => dataRow[keyFieldName]);
-    }
-    static getDataScopeFor2D(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);
-            return {
-                allowableKeys,
-                hidedRecordsAmount: dataLength - allowableKeys.length
-            };
-        }
-        return {
-            allowableKeys: this.getDataValuesByKeyField(data, configOptions.data.dataSource, configOptions.data.keyField.name),
-            hidedRecordsAmount: 0
-        };
-    }
-    static getDataScopeForPolar(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) {
-            return {
-                allowableKeys: keys,
-                hidedRecordsAmount: 0
-            };
-        }
-        let position;
-        if (canvas.getChartBlockWidth() >= MIN_DONUT_BLOCK_SIZE)
-            position = 'right';
-        else
-            position = 'bottom';
-        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);
-        }
-        return {
-            allowableKeys: keys.slice(0, maxItemsNumber),
-            hidedRecordsAmount: keys.length - maxItemsNumber
-        };
-    }
-    /**
-     * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
-     * @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 === 'polar' || config.options.type === '2d') {
-            // Форматиривание для оси ключей пока не совсем верно установлено
-            // if(config.options.data.keyField.format === 'date') {
-            //     data[config.options.data.dataSource] = this.getTypedData(data[config.options.data.dataSource], config.options.data.keyField);
-            // }
-        }
-        else 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;
-    }
-}