mdt-charts 1.38.3 → 1.38.5

package/lib/engine/features/gridLine/gidLineHelper.js

@@ -37,8 +37,9 @@ export class GridLineHelper {
         };
         const scaledStart = scaleValue(scaleValue.domain()[0]);
         const scaledEnd = scaleValue(scaleValue.domain()[1]);
-        const minCoord = min([scaledStart, scaledEnd]) - scaleValue(0);
-        const maxCoord = max([scaledStart, scaledEnd]) - scaleValue(0);
+        const minScaledValue = scaleValue(Math.min(...scaleValue.domain()));
+        const minCoord = min([scaledStart, scaledEnd]) - minScaledValue;
+        const maxCoord = max([scaledStart, scaledEnd]) - minScaledValue;
         if (axis.orient === "left" || axis.orient === "right") {
             attributes.x1 = minCoord;
             attributes.x2 = maxCoord;

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

@@ -1,6 +1,6 @@
 import { ScaleBand, ScaleLinear } from "d3-scale";
 import { AxisScale } from "d3-axis";
-import { BarChartSettings, ScaleBandModel, ScaleKeyModel, ScaleValueModel } from "../../../model/model";
+import { ScaleBandModel, ScaleKeyModel, ScaleValueModel } from "../../../model/model";
 export interface Scales {
     key: AxisScale<any>;
     value: AxisScale<any>;
@@ -9,13 +9,13 @@ export interface ScalesWithSecondary extends Scales {
     valueSecondary: AxisScale<any>;
 }
 export declare class Scale {
-    static getScales(scaleKey: ScaleKeyModel, scaleValue: ScaleValueModel, bandSettings: BarChartSettings): Scales;
-    static getScalesWithSecondary(scaleKey: ScaleKeyModel, scaleValue: ScaleValueModel, scaleValueSecondary: ScaleValueModel, bandSettings: BarChartSettings): ScalesWithSecondary;
+    static getScalesWithSecondary(scaleKey: ScaleKeyModel, scaleValue: ScaleValueModel, scaleValueSecondary: ScaleValueModel): ScalesWithSecondary;
     static getScaleValue(scaleValue: ScaleValueModel): ScaleLinear<number, number, number>;
     static getScaleBandWidth(scale: AxisScale<any>): number;
     static getScaleStep(scale: AxisScale<any>): number;
     static getScaledValueOnMiddleOfItem(scale: AxisScale<any>, value: any): number;
-    static getScaleBandNew(scaleKey: ScaleBandModel): ScaleBand<string>;
+    static getScaleBand(scaleKey: ScaleBandModel): ScaleBand<string>;
+    private static getScales;
     private static getScaleLinear;
     private static getScalePoint;
 }

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

@@ -1,25 +1,12 @@
 import { scaleBand, scaleLinear, scalePoint } from "d3-scale";
 //TODO: incapulate in model
 export class Scale {
-    static getScales(scaleKey, scaleValue, bandSettings) {
-        const scales = {
-            key: null,
-            value: null
-        };
-        if (scaleKey.type === "band")
-            // scales.key = this.getScaleBand(scaleKey.domain, scaleKey.range, bandSettings, scaleKey.elementsAmount);
-            scales.key = this.getScaleBandNew(scaleKey);
-        else if (scaleKey.type === "point")
-            scales.key = this.getScalePoint(scaleKey.domain, scaleKey.range);
-        scales.value = this.getScaleValue(scaleValue);
-        return scales;
-    }
-    static getScalesWithSecondary(scaleKey, scaleValue, scaleValueSecondary, bandSettings) {
-        const scales = this.getScales(scaleKey, scaleValue, bandSettings);
+    static getScalesWithSecondary(scaleKey, scaleValue, scaleValueSecondary) {
+        const scales = this.getScales(scaleKey, scaleValue);
         return Object.assign(Object.assign({}, scales), (scaleValueSecondary && { valueSecondary: this.getScaleValue(scaleValueSecondary) }));
     }
     static getScaleValue(scaleValue) {
-        return this.getScaleLinear(scaleValue.domain, scaleValue.range);
+        return this.getScaleLinear(scaleValue.domain, scaleValue.range, scaleValue.rootValue);
     }
     static getScaleBandWidth(scale) {
         if (scale.bandwidth && scale.bandwidth() !== 0) {
@@ -40,16 +27,34 @@ export class Scale {
         }
         return scale(value);
     }
-    static getScaleBandNew(scaleKey) {
+    static getScaleBand(scaleKey) {
+        // Formulas from d3-scale source code: https://github.com/d3/d3-scale/blob/main/src/band.js
+        const paddingInner = 1 - scaleKey.sizes.bandSize / scaleKey.sizes.recalculatedStepSize;
+        const paddingOuter = (Math.abs(scaleKey.range.end - scaleKey.range.start) / scaleKey.sizes.recalculatedStepSize -
+            scaleKey.domain.length +
+            paddingInner) /
+            2;
         return scaleBand()
             .domain(scaleKey.domain)
             .range([scaleKey.range.start, scaleKey.range.end])
-            .paddingInner(scaleKey.sizes.paddingInner / scaleKey.sizes.oneKeyTotalSpace)
-            .paddingOuter(scaleKey.sizes.paddingOuter / scaleKey.sizes.recalculatedStepSize);
+            .paddingInner(paddingInner)
+            .paddingOuter(paddingOuter);
+    }
+    static getScales(scaleKey, scaleValue) {
+        const scales = {
+            key: null,
+            value: null
+        };
+        if (scaleKey.type === "band")
+            scales.key = this.getScaleBand(scaleKey);
+        else if (scaleKey.type === "point")
+            scales.key = this.getScalePoint(scaleKey.domain, scaleKey.range);
+        scales.value = this.getScaleValue(scaleValue);
+        return scales;
     }
-    static getScaleLinear(domain, range) {
+    static getScaleLinear(domain, range, rootValue) {
         const scale = scaleLinear().domain(domain).range([range.start, range.end]);
-        scale.unknown(scale(0));
+        scale.unknown(scale(rootValue));
         return scale;
     }
     static getScalePoint(domain, range) {

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

@@ -19,10 +19,12 @@ export class AreaGeneratorFactory {
             ]
         });
         if (keyAxisOrient === "bottom" || keyAxisOrient === "top") {
-            return generator.getVertical((d) => Scale.getScaledValueOnMiddleOfItem(scales.key, d[keyFieldName]) + margin.left, (d) => scales.value(0) + margin.top, (d) => scales.value(d[valueFieldName]) + margin.top);
+            return generator.getVertical((d) => Scale.getScaledValueOnMiddleOfItem(scales.key, d[keyFieldName]) + margin.left, (d) => scales.value(undefined) + margin.top, //TODO: need a clearer way to use rootValue
+            (d) => scales.value(d[valueFieldName]) + margin.top);
         }
         if (keyAxisOrient === "left" || keyAxisOrient === "right") {
-            return generator.getHorizontal((d) => scales.value(0) + margin.left, (d) => scales.value(d[valueFieldName]) + margin.left, (d) => Scale.getScaledValueOnMiddleOfItem(scales.key, d[keyFieldName]) + margin.top);
+            return generator.getHorizontal((d) => scales.value(undefined) + margin.left, //TODO: need a clearer way to use rootValue
+            (d) => scales.value(d[valueFieldName]) + margin.left, (d) => Scale.getScaledValueOnMiddleOfItem(scales.key, d[keyFieldName]) + margin.top);
         }
     }
     getSegmentedAreaGenerator() {

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

@@ -47,7 +47,7 @@ export class BarHelper {
         }
     }
     static getBandItemValueStretch(scaleValue, valueFieldName) {
-        return (d) => Math.abs(scaleValue(d[valueFieldName]) - scaleValue(0));
+        return (d) => Math.abs(scaleValue(d[valueFieldName]) - scaleValue(undefined)); //TODO: need a clearer way to use rootValue
     }
     static setGroupedBandStartCoordinateAttr(attrs, keyAxisOrient, scaleValue, margin, valueFieldName) {
         if (keyAxisOrient === "top") {

package/lib/engine/twoDimensionalNotation/twoDimensionalManager.js

@@ -20,7 +20,7 @@ import { GroupLines } from "../features/groupLines/groupLines";
 export class TwoDimensionalManager {
     render(engine, model) {
         const options = model.options;
-        const scales = Scale.getScalesWithSecondary(options.scale.key, options.scale.value, options.scale.valueSecondary, options.chartSettings.bar);
+        const scales = Scale.getScalesWithSecondary(options.scale.key, options.scale.value, options.scale.valueSecondary);
         engine.block.scales = scales;
         engine.block.svg.render(model.blockCanvas.size);
         Axis.render(engine.block, scales, options.scale, options.axis, model.blockCanvas.size);
@@ -95,7 +95,7 @@ export class TwoDimensionalManager {
         Tooltip.hide(block);
         const options = model.options;
         ElementHighlighter.remove2DChartsFullHighlighting(block, options.charts);
-        const scales = Scale.getScalesWithSecondary(options.scale.key, options.scale.value, options.scale.valueSecondary, options.chartSettings.bar);
+        const scales = Scale.getScalesWithSecondary(options.scale.key, options.scale.value, options.scale.valueSecondary);
         const keyDomainEquality = Helper.checkDomainsEquality(block.scales.key.domain(), scales.key.domain());
         block.scales = scales;
         Axis.update(block, scales, options.scale, options.axis, model.blockCanvas.size, keyDomainEquality);

package/lib/model/featuresModel/scaleModel/scaleAxisRecalcer.js

@@ -9,12 +9,12 @@ export class ScaleAxisRecalcer {
         this.generateScaleLinear = generateScaleLinear;
     }
     recalculateMargin(canvasModel, chartOrientation, keyAxis) {
-        const { scaleFn: scaleValueFn } = this.getScaleValue();
+        const { scaleFn: scaleValueFn, scale } = this.getScaleValue();
         const coordinateOnChartBlock = keyAxis.position === "start"
-            ? scaleValueFn(0)
+            ? scaleValueFn(scale.rootValue)
             : (chartOrientation === "vertical"
                 ? canvasModel.getChartBlockHeight()
-                : canvasModel.getChartBlockWidth()) - scaleValueFn(0);
+                : canvasModel.getChartBlockWidth()) - scaleValueFn(scale.rootValue);
         const key = chartOrientation === "vertical" ? keyAxisLabelVerticalLog : keyAxisLabelHorizontalLog;
         const logInfo = canvasModel.marginService.getDataByKey(key);
         if (logInfo) {

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

@@ -1,6 +1,9 @@
 import { AxisNumberDomain, MdtChartsDataRow, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions, TwoDimensionalValueGroup } from "../../../config/config";
 export declare function getResolvedDomain(domain: AxisNumberDomain, dataRows: MdtChartsDataRow[]): import("../../../config/config").NumberDomain;
-export declare function getScaleLinearDomain(configDomain: AxisNumberDomain, dataRows: MdtChartsDataRow[], configOptions: MdtChartsTwoDimensionalOptions, valueGroup?: TwoDimensionalValueGroup): number[];
+export declare function getScaleLinearDomain(configDomain: AxisNumberDomain, dataRows: MdtChartsDataRow[], configOptions: MdtChartsTwoDimensionalOptions, valueGroup?: TwoDimensionalValueGroup): {
+    domain: [number, number];
+    rootValue: number;
+};
 export declare class ScaleDomainCalculator {
     getScaleMinValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;
     getScaleMaxValue(charts: MdtChartsTwoDimensionalChart[], dataRows: MdtChartsDataRow[]): number;

package/lib/model/featuresModel/scaleModel/scaleDomainService.js

@@ -11,16 +11,25 @@ export function getScaleLinearDomain(configDomain, dataRows, configOptions, valu
         return ((_a = chart.data.valueGroup) !== null && _a !== void 0 ? _a : "main") === valueGroup;
     });
     if (resolvedConfigDomain.start === -1)
-        domainPeekMin = calculator.getScaleMinValue(configOptions.charts, dataRows);
+        domainPeekMin = calculator.getScaleMinValue(charts, dataRows);
     else
         domainPeekMin = resolvedConfigDomain.start;
     if (resolvedConfigDomain.end === -1)
         domainPeekMax = calculator.getScaleMaxValue(charts, dataRows);
     else
         domainPeekMax = resolvedConfigDomain.end;
+    let rootValue = 0;
+    if (domainPeekMin === 0 || domainPeekMax === 0)
+        rootValue = 0;
+    else if (domainPeekMin < 0 && domainPeekMax > 0)
+        rootValue = 0;
+    else if (domainPeekMax > 0 && domainPeekMin > 0)
+        rootValue = Math.min(domainPeekMin, domainPeekMax);
+    else if (domainPeekMin < 0 && domainPeekMax < 0)
+        rootValue = Math.max(domainPeekMin, domainPeekMax);
     if (configOptions.axis.key.position === "start")
-        return [domainPeekMin, domainPeekMax];
-    return [domainPeekMax, domainPeekMin];
+        return { domain: [domainPeekMin, domainPeekMax], rootValue };
+    return { domain: [domainPeekMax, domainPeekMin], rootValue };
 }
 export class ScaleDomainCalculator {
     getScaleMinValue(charts, dataRows) {

package/lib/model/featuresModel/scaleModel/scaleModel.js

@@ -31,8 +31,10 @@ export class ScaleModel {
     }
     getScaleLinear(dataRows, configReader) {
         var _a;
+        const { domain, rootValue } = getScaleLinearDomain(this.options.axis.value.domain, dataRows, this.options);
         return {
-            domain: getScaleLinearDomain(this.options.axis.value.domain, dataRows, this.options),
+            domain,
+            rootValue,
             range: {
                 start: 0,
                 end: getScaleValueRangePeek(this.options.orientation, this.canvasModel)
@@ -43,8 +45,10 @@ export class ScaleModel {
     }
     getScaleSecondaryLinear(dataRows, configReader) {
         var _a;
+        const { domain, rootValue } = getScaleLinearDomain(this.options.axis.valueSecondary.domain, dataRows, this.options, "secondary");
         return {
-            domain: getScaleLinearDomain(this.options.axis.valueSecondary.domain, dataRows, this.options, "secondary"),
+            domain,
+            rootValue,
             range: {
                 start: 0,
                 end: getScaleValueRangePeek(this.options.orientation, this.canvasModel)

package/lib/model/model.d.ts

@@ -145,7 +145,8 @@ export interface ScalePointModel extends BaseScaleKeyModel {
     type: "point";
 }
 export interface ScaleValueModel {
-    domain: any[];
+    domain: number[];
+    rootValue: number;
     range: RangeModel;
     type: ScaleValueType;
     formatter: ((v: number) => string) | null;

package/lib/model/notations/twoDimensionalModel.js

@@ -33,7 +33,7 @@ export class TwoDimensionalModel {
             secondaryScaleMarginRecalcer.recalculateMargin(canvasModel, options.orientation, options.axis.key);
             secondaryScaleValueInfo = secondaryScaleMarginRecalcer.getScaleValue();
         }
-        const keyAxis = AxisModel.getKeyAxis(options, modelInstance.dataModel.repository.getScopedFullSource(), designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip, () => scaleValueInfo.scaleFn(0));
+        const keyAxis = AxisModel.getKeyAxis(options, modelInstance.dataModel.repository.getScopedFullSource(), designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip, () => scaleValueInfo.scaleFn(scaleValueInfo.scale.rootValue));
         const keyScale = scaleModel.getScaleKey(modelInstance.dataModel.getAllowableKeys());
         const charts = this.getChartsModel(options.charts, configReader, options.orientation, designerConfig, modelInstance.dataModel.repository, keyAxis.orient, canvasModel, options.data.keyField.name, modelInstance, keyScale);
         const titleConfig = TitleConfigReader.create(options.title, modelInstance);

package/package.json

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