mdt-charts 1.12.4 → 1.12.5

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

@@ -1,3 +1,4 @@
+import { ScaleLinear, ScaleTime } from 'd3-scale';
 import { AxisScale } from 'd3-axis';
 import { BarChartSettings, ScaleKeyModel, ScaleValueModel } from '../../../model/model';
 export interface Scales {
@@ -6,6 +7,7 @@ export interface Scales {
 }
 export declare class Scale {
     static getScales(scaleKey: ScaleKeyModel, scaleValue: ScaleValueModel, bandSettings: BarChartSettings): Scales;
+    static getScaleValue(scaleValue: ScaleValueModel): ScaleLinear<number, number, never> | ScaleTime<number, number, never>;
     static getScaleBandWidth(scale: AxisScale<any>): number;
     static getScaleStep(scale: AxisScale<any>): number;
     static getScaledValue(scale: AxisScale<any>, value: any): number;

package/lib/engine/features/scale/scale.js

@@ -9,11 +9,14 @@ export class Scale {
             scales.key = this.getScaleBand(scaleKey.domain, scaleKey.range, bandSettings, scaleKey.elementsAmount);
         else if (scaleKey.type === 'point')
             scales.key = this.getScalePoint(scaleKey.domain, scaleKey.range);
+        scales.value = this.getScaleValue(scaleValue);
+        return scales;
+    }
+    static getScaleValue(scaleValue) {
         if (scaleValue.type === 'linear')
-            scales.value = this.getScaleLinear(scaleValue.domain, scaleValue.range);
+            return this.getScaleLinear(scaleValue.domain, scaleValue.range);
         else if (scaleValue.type === 'datetime')
-            scales.value = this.getScaleTime(scaleValue.domain, scaleValue.range);
-        return scales;
+            return this.getScaleTime(scaleValue.domain, scaleValue.range);
     }
     static getScaleBandWidth(scale) {
         if (scale.bandwidth && scale.bandwidth() !== 0) {

package/lib/engine/twoDimensionalNotation/area/areaHelper.js

@@ -5,11 +5,11 @@ export class AreaHelper {
         if (keyAxisOrient === 'bottom' || keyAxisOrient === 'top')
             return area()
                 .x(d => Scale.getScaledValue(scales.key, d[keyFieldName]) + margin.left)
-                .y0(d => this.getZeroCoordinate(keyAxisOrient, margin, blockSize))
+                .y0(d => scales.value(0) + margin.top)
                 .y1(d => scales.value(d[valueFieldName]) + margin.top);
         if (keyAxisOrient === 'left' || keyAxisOrient === 'right')
             return area()
-                .x0(d => this.getZeroCoordinate(keyAxisOrient, margin, blockSize))
+                .x0(d => scales.value(0) + margin.left)
                 .x1(d => scales.value(d[valueFieldName]) + margin.left)
                 .y(d => Scale.getScaledValue(scales.key, d[keyFieldName]) + margin.top);
     }

package/lib/engine/twoDimensionalNotation/bar/bar.js

@@ -171,15 +171,15 @@ export class Bar {
                 resolve('');
                 return;
             }
-            let barsHander = bars;
+            let barsHandler = bars;
             if (transitionDuration > 0) {
-                barsHander = barsHander
+                barsHandler = barsHandler
                     .interrupt()
                     .transition()
                     .duration(transitionDuration)
                     .on('end', () => resolve(''));
             }
-            barsHander.attr('x', d => barAttrs.x(d))
+            barsHandler.attr('x', d => barAttrs.x(d))
                 .attr('y', d => barAttrs.y(d))
                 .attr('height', d => barAttrs.height(d))
                 .attr('width', d => barAttrs.width(d));

package/lib/engine/twoDimensionalNotation/bar/barHelper.js

@@ -66,20 +66,20 @@ export class BarHelper {
     }
     static setGroupedBarAttrsByValue(attrs, keyAxisOrient, margin, scaleValue, valueFieldName, blockSize) {
         if (keyAxisOrient === 'top') {
-            attrs.y = d => margin.top;
-            attrs.height = d => Helper.getValueOrZero(scaleValue(d[valueFieldName]));
+            attrs.y = d => scaleValue(Math.min(d[valueFieldName], 0)) + margin.top;
+            attrs.height = d => Math.abs(scaleValue(d[valueFieldName]) - scaleValue(0));
         }
         if (keyAxisOrient === 'bottom') {
-            attrs.y = d => scaleValue(d[valueFieldName]) + margin.top;
-            attrs.height = d => Helper.getValueOrZero(blockSize.height - margin.top - margin.bottom - scaleValue(d[valueFieldName]));
+            attrs.y = d => scaleValue(Math.max(d[valueFieldName], 0)) + margin.top;
+            attrs.height = d => Math.abs(scaleValue(d[valueFieldName]) - scaleValue(0));
         }
         if (keyAxisOrient === 'left') {
-            attrs.x = d => margin.left + 1;
-            attrs.width = d => Helper.getValueOrZero(scaleValue(d[valueFieldName]));
+            attrs.x = d => scaleValue(Math.min(d[valueFieldName], 0)) + margin.left;
+            attrs.width = d => Math.abs(scaleValue(d[valueFieldName]) - scaleValue(0));
         }
         if (keyAxisOrient === 'right') {
-            attrs.x = d => scaleValue(d[valueFieldName]) + margin.left;
-            attrs.width = d => Helper.getValueOrZero(blockSize.width - margin.left - margin.right - scaleValue(d[valueFieldName]));
+            attrs.x = d => scaleValue(Math.max(d[valueFieldName], 0)) + margin.left;
+            attrs.width = d => Math.abs(scaleValue(d[valueFieldName]) - scaleValue(0));
         }
     }
     static setSegmentedBarAttrsByValue(attrs, keyAxisOrient, scaleValue, margin, blockSize) {

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

@@ -9,7 +9,7 @@ export interface LabelSize {
 }
 export declare class AxisModel {
     private static service;
-    static getKeyAxis(options: MdtChartsTwoDimensionalOptions, data: MdtChartsDataSource, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, tooltipSettings: TooltipSettings): AxisModelOptions;
+    static getKeyAxis(options: MdtChartsTwoDimensionalOptions, data: MdtChartsDataSource, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, tooltipSettings: TooltipSettings, getZeroCoordinate?: () => number): AxisModelOptions;
     static getValueAxis(orient: ChartOrientation, axisConfig: NumberAxisOptions, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel): AxisModelOptions;
     static getAxisLength(chartOrientation: ChartOrientation, canvasModel: CanvasModel): number;
     static getAxisOrient(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition): Orient;
@@ -17,4 +17,5 @@ export declare class AxisModel {
     static getAxisTranslateY(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition, canvasModel: CanvasModel): number;
     static getKeyAxisLabelPosition(canvasModel: CanvasModel, scopedDataLength: number, axisConfig?: DiscreteAxisOptions): AxisLabelPosition;
     static getLabelSize(labelMaxWidth: number, labelTexts: any[]): LabelSize;
+    private static getKeyAxisTranslateModel;
 }

package/lib/model/featuresModel/axisModel.js

@@ -4,16 +4,14 @@ import { DataManagerModel } from "../dataManagerModel/dataManagerModel";
 import { TwoDimensionalModel } from "../notations/twoDimensionalModel";
 import { AxisModelService } from "./axisModelService";
 export class AxisModel {
-    static getKeyAxis(options, data, labelConfig, canvasModel, tooltipSettings) {
+    static getKeyAxis(options, data, labelConfig, canvasModel, tooltipSettings, getZeroCoordinate) {
         const { charts, orientation, data: dataOptions } = options;
         const axisConfig = options.axis.key;
+        const translate = this.getKeyAxisTranslateModel(orientation, axisConfig.position, canvasModel, getZeroCoordinate);
         return {
             type: 'key',
             orient: AxisModel.getAxisOrient(AxisType.Key, orientation, axisConfig.position),
-            translate: {
-                translateX: AxisModel.getAxisTranslateX(AxisType.Key, orientation, axisConfig.position, canvasModel),
-                translateY: AxisModel.getAxisTranslateY(AxisType.Key, orientation, axisConfig.position, canvasModel)
-            },
+            translate,
             cssClass: 'key-axis',
             ticks: axisConfig.ticks,
             labels: {
@@ -109,5 +107,22 @@ export class AxisModel {
         textBlock.remove();
         return labelSize;
     }
+    static getKeyAxisTranslateModel(chartOrientation, axisPosition, canvasModel, getZeroCoordinate) {
+        let translateY;
+        let translateX;
+        if (chartOrientation === "vertical") {
+            translateY = getZeroCoordinate() + canvasModel.getMarginSide("top");
+            translateX = AxisModel.getAxisTranslateX(AxisType.Key, chartOrientation, axisPosition, canvasModel);
+        }
+        else {
+            translateX = getZeroCoordinate() + canvasModel.getMarginSide("left");
+            translateY = AxisModel.getAxisTranslateY(AxisType.Key, chartOrientation, axisPosition, canvasModel);
+        }
+        console.log(translateX, translateY);
+        return {
+            translateX,
+            translateY
+        };
+    }
 }
 AxisModel.service = new AxisModelService();

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

@@ -1,5 +1,5 @@
 import { ScaleKeyModel, ScaleKeyType, ScaleValueModel, ScaleValueType } from "../model";
-import { AxisPosition, NumberDomain, IntervalChart, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions, ChartOrientation, MdtChartsDataSource } from "../../config/config";
+import { AxisPosition, NumberDomain, IntervalChart, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions, ChartOrientation, MdtChartsDataSource, MdtChartsDataRow } from "../../config/config";
 import { CanvasModel } from "../modelInstance/canvasModel/canvasModel";
 export declare enum ScaleType {
     Key = 0,
@@ -14,5 +14,6 @@ export declare class ScaleModel {
     static getScaleKeyType(charts: MdtChartsTwoDimensionalChart[]): ScaleKeyType;
     static getScaleValueType(charts: MdtChartsTwoDimensionalChart[] | IntervalChart[]): ScaleValueType;
     static getElementsAmount(barCharts: MdtChartsTwoDimensionalChart[]): number;
-    static getScaleMaxValue(charts: MdtChartsTwoDimensionalChart[], dataSource: string, data: MdtChartsDataSource): number;
+    static getScaleMaxValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;
+    static getScaleMinValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;
 }

package/lib/model/featuresModel/scaleModel.js

@@ -47,11 +47,11 @@ export class ScaleModel {
         let domainPeekMin;
         let domainPeekMax;
         if (configDomain.start === -1)
-            domainPeekMin = 0;
+            domainPeekMin = this.getScaleMinValue(configOptions.charts, data[configOptions.data.dataSource]);
         else
             domainPeekMin = configDomain.start;
         if (configDomain.end === -1)
-            domainPeekMax = this.getScaleMaxValue(configOptions.charts, configOptions.data.dataSource, data);
+            domainPeekMax = this.getScaleMaxValue(configOptions.charts, data[configOptions.data.dataSource]);
         else
             domainPeekMax = configDomain.end;
         if (configOptions.axis.key.position === 'start')
@@ -80,10 +80,10 @@ export class ScaleModel {
         });
         return barsAmount;
     }
-    static getScaleMaxValue(charts, dataSource, data) {
+    static getScaleMaxValue(charts, dataRows) {
         let max = 0;
         charts.forEach(chart => {
-            data[dataSource].forEach(dataRow => {
+            dataRows.forEach(dataRow => {
                 let sumInRow = 0;
                 chart.data.valueFields.forEach(field => {
                     if (chart.isSegmented)
@@ -97,4 +97,19 @@ export class ScaleModel {
         });
         return max;
     }
+    static getScaleMinValue(charts, dataRows) {
+        let min = 0;
+        charts.forEach(chart => {
+            dataRows.forEach(dataRow => {
+                let sumInRow = 0;
+                chart.data.valueFields.forEach(field => {
+                    if (dataRow[field.name] < sumInRow)
+                        sumInRow = dataRow[field.name];
+                });
+                if (min > sumInRow)
+                    min = sumInRow;
+            });
+        });
+        return min;
+    }
 }

package/lib/model/marginModel.d.ts

@@ -1,13 +1,12 @@
 import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
 import { DesignerConfig } from "../designer/designerConfig";
-import { DataScope, LegendBlockModel, Orient, OtherCommonComponents, PolarOptionsModel } from "./model";
+import { DataScope, LegendBlockModel, Orient, OtherCommonComponents } 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 {
     static initMargin(designerConfig: DesignerConfig, config: MdtChartsConfig, otherComponents: OtherCommonComponents, data: MdtChartsDataSource, modelInstance: ModelInstance): void;
-    static recalcPolarMarginWithScopedData(modelInstance: ModelInstance, designerConfig: DesignerConfig, config: MdtChartsConfig, legendBlockModel: LegendBlockModel, dataScope: DataScope, options: PolarOptionsModel): void;
     static recalcMarginByVerticalAxisLabel(modelInstance: ModelInstance, config: MdtChartsConfig, designerConfig: DesignerConfig, dataScope: DataScope): void;
     private static getHorizontalMarginByAxisLabels;
     private static recalcVerticalMarginByAxisLabelHeight;
@@ -15,6 +14,5 @@ export declare class MarginModel {
     private static recalcMarginWithLegend;
     private static getLegendItemsContent;
     static appendToGlobalMarginValuesLegendMargin(canvasModel: CanvasModel, position: Orient, legendBlockModel: LegendBlockModel): void;
-    private static clearMarginByLegendBlockPosition;
     private static recalcMarginByTitle;
 }

package/lib/model/marginModel.js

@@ -3,7 +3,6 @@ import { DataManagerModel } from "./dataManagerModel/dataManagerModel";
 import { LegendModel } from "./featuresModel/legendModel/legendModel";
 import { AxisType } from "./modelBuilder";
 import { TwoDimensionalModel } from "./notations/twoDimensionalModel";
-import { PolarModel } from "./notations/polar/polarModel";
 export const AXIS_HORIZONTAL_LABEL_PADDING = 15;
 export const AXIS_VERTICAL_LABEL_PADDING = 10;
 export class MarginModel {
@@ -24,21 +23,6 @@ export class MarginModel {
             this.recalcHorizontalMarginByAxisLabelWidth(labelSize, canvasModel, config.options.orientation, config.options.axis, showingFlag);
         }
     }
-    static recalcPolarMarginWithScopedData(modelInstance, designerConfig, config, legendBlockModel, dataScope, options) {
-        const canvasModel = modelInstance.canvasModel;
-        let position = canvasModel.legendCanvas.getPosition();
-        if (position !== 'off') {
-            position = PolarModel.getLegendPositionByBlockSize(canvasModel); // reset position
-            this.clearMarginByLegendBlockPosition(canvasModel, legendBlockModel);
-            let allowableKeys = [...dataScope.allowableKeys];
-            if (dataScope.hidedRecordsAmount !== 0 && position === 'bottom')
-                allowableKeys.push('1'); // Если есть спрятанные записи, то в массив добавляется объект, чтобы выделить место в легенде для индикатора переполнения
-            const legendSize = LegendModel.getLegendSize(config.options.type, position, allowableKeys, designerConfig.canvas.legendBlock.maxWidth, config.canvas.size, legendBlockModel);
-            canvasModel.increaseMarginSide(position, legendSize + legendBlockModel.coordinate[position].margin[position]);
-            legendBlockModel.coordinate[position].size = legendSize;
-            options.legend.position = position;
-        }
-    }
     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);
@@ -117,15 +101,6 @@ export class MarginModel {
         else
             canvasModel.increaseMarginSide(position, legendCoordinate[position].margin.top + legendCoordinate[position].margin.bottom);
     }
-    static clearMarginByLegendBlockPosition(canvasModel, legendBlockModel) {
-        const legendCoordinate = legendBlockModel.coordinate;
-        ['left', 'right', 'top', 'bottom'].forEach((position) => {
-            const decreaseByValue = legendCoordinate[position].size === 0
-                ? 0
-                : legendCoordinate[position].size + legendCoordinate[position].margin[position];
-            canvasModel.descreaseMarginSide(position, decreaseByValue);
-        });
-    }
     static recalcMarginByTitle(canvasModel, titleBlockModel) {
         canvasModel.increaseMarginSide("top", titleBlockModel.margin.top + titleBlockModel.size + titleBlockModel.margin.bottom);
     }

package/lib/model/notations/twoDimensionalModel.js

@@ -1,3 +1,4 @@
+import { Scale } from "../../engine/features/scale/scale";
 import { ChartStyleModelService } from "../chartStyleModel/chartStyleModel";
 import { TwoDimensionalChartStyleModel } from "../chartStyleModel/TwoDimensionalChartStyleModel";
 import { AxisModel } from "../featuresModel/axisModel";
@@ -5,17 +6,22 @@ import { ScaleModel } from "../featuresModel/scaleModel";
 export class TwoDimensionalModel {
     static getOptions(options, designerConfig, data, modelInstance) {
         const canvasModel = modelInstance.canvasModel;
+        const scaleKey = ScaleModel.getScaleKey(modelInstance.dataModel.getAllowableKeys(), options.orientation, canvasModel, options.charts, this.getChartsByType(options.charts, 'bar'));
+        const scaleValue = ScaleModel.getScaleLinear(options, data, canvasModel);
+        const chartSettings = this.getChartsSettings(designerConfig.canvas.chartOptions.bar);
+        //TODO: rm import from engine
+        const scaleValueFn = Scale.getScaleValue(scaleValue);
         return {
             legend: canvasModel.legendCanvas.getModel(),
             title: options.title,
             selectable: !!options.selectable,
             orient: options.orientation,
             scale: {
-                key: ScaleModel.getScaleKey(modelInstance.dataModel.getAllowableKeys(), options.orientation, canvasModel, options.charts, this.getChartsByType(options.charts, 'bar')),
-                value: ScaleModel.getScaleLinear(options, data, canvasModel)
+                key: scaleKey,
+                value: scaleValue
             },
             axis: {
-                key: AxisModel.getKeyAxis(options, data, designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip),
+                key: AxisModel.getKeyAxis(options, data, designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip, () => scaleValueFn(0)),
                 value: AxisModel.getValueAxis(options.orientation, options.axis.value, designerConfig.canvas.axisLabel, canvasModel)
             },
             type: options.type,
@@ -23,7 +29,7 @@ export class TwoDimensionalModel {
             charts: this.getChartsModel(options.charts, options.orientation, designerConfig.chartStyle),
             additionalElements: this.getAdditionalElements(options),
             tooltip: options.tooltip,
-            chartSettings: this.getChartsSettings(designerConfig.canvas.chartOptions.bar)
+            chartSettings
         };
     }
     static getChartsEmbeddedLabelsFlag(charts, chartOrientation) {

package/lib/style/charts-main.css

@@ -58,6 +58,7 @@
 .legend-item {
     cursor: default;
     transition: opacity 0.1s;
+    line-height: 1;
     /* will-change: opacity;      */
 }
 .legend-block-column .legend-item:not(:first-of-type) {

package/lib/style/charts-main.less

@@ -58,6 +58,7 @@
 .legend-item {
     cursor: default;
     transition: opacity 0.1s;
+    line-height: 1;
     /* will-change: opacity;      */
 }
 .legend-block-column .legend-item:not(:first-of-type) {

package/package.json

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