mdt-charts 1.27.1 → 1.27.2

package/lib/model/dataManagerModel/dataManagerModel.js

@@ -11,10 +11,10 @@ export class DataManagerModel {
         return scopedData;
     }
     static initDataScope(config, data, designerConfig, legendBlock, modelInstance) {
-        if (config.options.type === '2d') {
+        if (config.options.type === "2d") {
             this.initDataScopeFor2D(config.options, modelInstance, data, designerConfig);
         }
-        else if (config.options.type === 'polar') {
+        else if (config.options.type === "polar") {
             this.initDataScopeForPolar(config.options, modelInstance, data, legendBlock, designerConfig.canvas.legendBlock);
         }
         this.initScopedData(data, modelInstance, config);
@@ -24,12 +24,12 @@ export class DataManagerModel {
         modelInstance.dataModel.repository.initScopedFullSource(preparedData);
     }
     static getDataValuesByKeyField(data, dataSourceName, keyFieldName) {
-        return data[dataSourceName].map(dataRow => dataRow[keyFieldName]);
+        return data[dataSourceName].map((dataRow) => dataRow[keyFieldName]);
     }
     static initDataScopeFor2D(configOptions, modelInstance, data, designerConfig) {
         modelInstance.dataModel.initMaxRecordsAmount(configOptions.data.maxRecordsAmount);
         const axisLength = AxisModel.getAxisLength(configOptions.orientation, modelInstance.canvasModel);
-        const uniqueKeys = ModelHelper.getUniqueValues(data[configOptions.data.dataSource].map(d => d[configOptions.data.keyField.name]));
+        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), dataLength, axisLength, designerConfig.canvas.chartOptions.bar);
         const allowableKeys = uniqueKeys.slice(0, limit);
@@ -40,7 +40,7 @@ export class DataManagerModel {
         modelInstance.dataModel.initMaxRecordsAmount(configOptions.data.maxRecordsAmount);
         const canvasModel = modelInstance.canvasModel;
         const keyFieldName = configOptions.data.keyField.name;
-        const keys = data[configOptions.data.dataSource].map(dataRow => dataRow[keyFieldName]);
+        const keys = data[configOptions.data.dataSource].map((dataRow) => dataRow[keyFieldName]);
         if (!configOptions.legend.show) {
             canvasModel.legendCanvas.setPosition("off");
             modelInstance.dataModel.initScope(this.getMaximumPossibleScope(keys, modelInstance.dataModel));
@@ -48,7 +48,8 @@ export class DataManagerModel {
         }
         let position = PolarModel.getLegendPositionByBlockSize(modelInstance.canvasModel);
         let { amount: maxItemsNumber, size } = this.getLegendDataParams(position, keys, legendCanvas, canvasModel, legendBlock);
-        if (position === "right" && !PolarModel.doesChartBlockHasEnoughWidthForContainsLegend(canvasModel.getChartBlockWidth(), size.width, legendBlock.coordinate)) {
+        if (position === "right" &&
+            !PolarModel.doesChartBlockHasEnoughWidthForContainsLegend(canvasModel.getChartBlockWidth(), size.width, legendBlock.coordinate)) {
             const doesFreeSpaceExist = PolarModel.doesChartBlockHasEnoughHeightForContainsLegend(canvasModel.getChartBlockHeight(), legendBlock.coordinate);
             if (doesFreeSpaceExist) {
                 const newParams = this.getLegendDataParams("bottom", keys, legendCanvas, canvasModel, legendBlock);
@@ -66,16 +67,21 @@ export class DataManagerModel {
     }
     //TODO: position type
     static getLegendDataParams(position, keys, legendCanvas, canvasModel, legendBlock) {
-        const legendItemContentOptions = keys.map(k => ({
+        const legendItemContentOptions = keys.map((k) => ({
             text: k,
             markerSize: styledElementValues.defaultLegendMarkerSizes,
             wrapperSize: { marginRightPx: styledElementValues.legend.inlineDynamicItemWrapperMarginRightPx }
         }));
-        if (position === 'right') {
+        if (position === "right") {
             return LegendCanvasModel.findElementsAmountByLegendSize(legendItemContentOptions, position, this.polarMarginCalculator.getMaxLegendWidth(legendCanvas, canvasModel.getBlockSize().width), canvasModel.getChartBlockHeight() - legendBlock.coordinate.right.margin.bottom);
         }
         else {
-            return LegendCanvasModel.findElementsAmountByLegendSize(legendItemContentOptions, position, canvasModel.getChartBlockWidth() - legendBlock.coordinate.bottom.margin.left - legendBlock.coordinate.bottom.margin.right, canvasModel.getChartBlockHeight() - legendBlock.coordinate.bottom.margin.bottom - legendBlock.coordinate.bottom.margin.top - MIN_DONUT_BLOCK_SIZE);
+            return LegendCanvasModel.findElementsAmountByLegendSize(legendItemContentOptions, position, canvasModel.getChartBlockWidth() -
+                legendBlock.coordinate.bottom.margin.left -
+                legendBlock.coordinate.bottom.margin.right, canvasModel.getChartBlockHeight() -
+                legendBlock.coordinate.bottom.margin.bottom -
+                legendBlock.coordinate.bottom.margin.top -
+                MIN_DONUT_BLOCK_SIZE);
         }
     }
     static getMaximumPossibleScope(keys, dataModel) {
@@ -90,13 +96,13 @@ export class DataManagerModel {
      * @param chartsLength
      */
     static getElementsInGroupAmount(configOptions) {
-        const bars = this.getBarLikeChartsInGroupAmount(configOptions.charts, 'bar');
-        const dots = configOptions.charts.some(chart => chart.type === 'dot') ? 1 : 0;
+        const bars = this.getBarLikeChartsInGroupAmount(configOptions.charts, "bar");
+        const dots = configOptions.charts.some((chart) => chart.type === "dot") ? 1 : 0;
         return Math.max(bars, dots);
     }
     static getBarLikeChartsInGroupAmount(charts, type) {
         let barsAmount = 0;
-        charts.forEach(chart => {
+        charts.forEach((chart) => {
             if (chart.type === type && chart.isSegmented)
                 barsAmount += 1; // в сегментированном баре все valueFields находятся внутри одного бара, поэтому бар всегда один.
             else if (chart.type === type)
@@ -110,15 +116,21 @@ export class DataManagerModel {
         return newData;
     }
     static getScopedChartData(data, allowableKeys, keyFieldName) {
-        return data.filter(d => allowableKeys.findIndex(key => key === d[keyFieldName]) !== -1);
+        return data.filter((d) => allowableKeys.findIndex((key) => key === d[keyFieldName]) !== -1);
     }
     static getDataLimitByItemSize(elementsInGroupAmount, dataLength, axisLength, barOptions) {
-        let sumSize = dataLength * (elementsInGroupAmount * barOptions.minBarWidth + (elementsInGroupAmount - 1) * barOptions.barDistance + barOptions.groupMinDistance);
+        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);
+            sumSize =
+                dataLength *
+                    (elementsInGroupAmount * barOptions.minBarWidth +
+                        (elementsInGroupAmount - 1) * barOptions.barDistance +
+                        barOptions.groupMinDistance);
         }
         return dataLength;
     }

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

@@ -1,5 +1,5 @@
 import { AxisPosition, ChartOrientation, MdtChartsDataSource, NumberAxisOptions, AxisLabelPosition, MdtChartsTwoDimensionalOptions, DiscreteAxisOptions, NumberSecondaryAxisOptions, AxisLabelFormatter } from "../../config/config";
-import { AxisModelOptions, Orient } from "../model";
+import { AxisModelOptions, Orient, ScaleValueModel, TickAmountPolicy } from "../model";
 import { AxisType } from "../modelBuilder";
 import { AxisLabelCanvas, TooltipSettings } from "../../designer/designerConfig";
 import { CanvasModel } from "../modelInstance/canvasModel/canvasModel";
@@ -9,11 +9,12 @@ export interface LabelSize {
 }
 export declare const MINIMAL_VERTICAL_STEP_SIZE = 60;
 export declare const MINIMAL_HORIZONTAL_STEP_SIZE = 100;
+export declare const LABEL_ELEMENT_HEIGHT_PX = 17;
 export declare class AxisModel {
     private static service;
     static getKeyAxis(options: MdtChartsTwoDimensionalOptions, data: MdtChartsDataSource, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, tooltipSettings: TooltipSettings, getZeroCoordinate?: () => number): AxisModelOptions;
-    static getMainValueAxis(defaultFormatter: AxisLabelFormatter, orient: ChartOrientation, position: AxisPosition, axisConfig: NumberAxisOptions, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel): AxisModelOptions;
-    static getSecondaryValueAxis(defaultFormatter: AxisLabelFormatter, orient: ChartOrientation, mainAxisPosition: AxisPosition, axisConfig: NumberSecondaryAxisOptions, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel): AxisModelOptions;
+    static getMainValueAxis(defaultFormatter: AxisLabelFormatter, orient: ChartOrientation, position: AxisPosition, axisConfig: NumberAxisOptions, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, scaleInfo: ScaleValueModel): AxisModelOptions;
+    static getSecondaryValueAxis(defaultFormatter: AxisLabelFormatter, orient: ChartOrientation, mainAxisPosition: AxisPosition, axisConfig: NumberSecondaryAxisOptions, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, scaleInfo: ScaleValueModel): AxisModelOptions;
     private static getValueAxis;
     static getAxisLength(chartOrientation: ChartOrientation, canvasModel: CanvasModel): number;
     static getAxisOrient(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition): Orient;
@@ -22,5 +23,7 @@ export declare class AxisModel {
     static getKeyAxisLabelPosition(canvasModel: CanvasModel, scopedDataLength: number, axisConfig?: DiscreteAxisOptions): AxisLabelPosition;
     static getLabelSize(labelMaxWidth: number, labelTexts: string[]): LabelSize;
     static getRoundValue(value: number): number;
+    static getTickAmountPolicy(orient: ChartOrientation, axisConfig: NumberAxisOptions | NumberSecondaryAxisOptions, scaleInfo: ScaleValueModel): TickAmountPolicy;
     private static getKeyAxisTranslateModel;
+    private static getTickStep;
 }

package/lib/model/featuresModel/axisModel.js

@@ -3,8 +3,10 @@ import { AxisType } from "../modelBuilder";
 import { DataManagerModel } from "../dataManagerModel/dataManagerModel";
 import { TwoDimensionalModel } from "../notations/twoDimensionalModel";
 import { AxisModelService, AxisModelTickCalculator, showAllTicks } from "./axisModelService";
+import { max, min } from "d3-array";
 export const MINIMAL_VERTICAL_STEP_SIZE = 60;
 export const MINIMAL_HORIZONTAL_STEP_SIZE = 100;
+export const LABEL_ELEMENT_HEIGHT_PX = 17;
 const DEFAULT_AXIS_LINE_VISIBLE = true;
 export class AxisModel {
     static getKeyAxis(options, data, labelConfig, canvasModel, tooltipSettings, getZeroCoordinate) {
@@ -14,38 +16,42 @@ export class AxisModel {
         const translate = this.getKeyAxisTranslateModel(orientation, axisConfig.position, canvasModel, getZeroCoordinate);
         const tickCalculator = new AxisModelTickCalculator(data[dataOptions.dataSource], (_a = options.axis.key.labels) === null || _a === void 0 ? void 0 : _a.showRule);
         return {
-            type: 'key',
+            type: "key",
             orient: AxisModel.getAxisOrient(AxisType.Key, orientation, axisConfig.position),
             translate,
-            cssClass: 'key-axis',
+            cssClass: "key-axis",
             ticks: axisConfig.ticks,
             labels: {
-                maxSize: AxisModel.getLabelSize(labelConfig.maxSize.main, data[dataOptions.dataSource].map(d => d[dataOptions.keyField.name])).width,
-                position: AxisModel.getKeyAxisLabelPosition(canvasModel, DataManagerModel.getDataValuesByKeyField(data, dataOptions.dataSource, dataOptions.keyField.name).length, axisConfig),
+                maxSize: AxisModel.getLabelSize(labelConfig.maxSize.main, data[dataOptions.dataSource].map((d) => d[dataOptions.keyField.name])).width,
+                position: AxisModel.getKeyAxisLabelPosition(canvasModel, DataManagerModel.getDataValuesByKeyField(data, dataOptions.dataSource, dataOptions.keyField.name)
+                    .length, axisConfig),
                 visible: !TwoDimensionalModel.getChartsEmbeddedLabelsFlag(charts, orientation),
-                defaultTooltip: tooltipSettings.position === 'fixed',
+                defaultTooltip: tooltipSettings.position === "fixed",
                 showTick: tickCalculator.createFunctionCalculator(this.getAxisLength(orientation, canvasModel)),
-                linearTickStep: MINIMAL_HORIZONTAL_STEP_SIZE
+                linearTickStep: MINIMAL_HORIZONTAL_STEP_SIZE,
+                tickAmountSettings: {
+                    policy: { type: "auto" }
+                }
             },
             visibility: axisConfig.visibility,
             line: {
                 visible: (_c = (_b = axisConfig.line) === null || _b === void 0 ? void 0 : _b.visible) !== null && _c !== void 0 ? _c : DEFAULT_AXIS_LINE_VISIBLE
             },
             browserTooltip: {
-                format: value => value
+                format: (value) => value
             }
         };
     }
-    static getMainValueAxis(defaultFormatter, orient, position, axisConfig, labelConfig, canvasModel) {
-        return this.getValueAxis(defaultFormatter, orient, position, 'value-axis', axisConfig, labelConfig, canvasModel);
+    static getMainValueAxis(defaultFormatter, orient, position, axisConfig, labelConfig, canvasModel, scaleInfo) {
+        return this.getValueAxis(defaultFormatter, orient, position, "value-axis", axisConfig, labelConfig, canvasModel, scaleInfo);
     }
-    static getSecondaryValueAxis(defaultFormatter, orient, mainAxisPosition, axisConfig, labelConfig, canvasModel) {
-        return this.getValueAxis(defaultFormatter, orient, mainAxisPosition === "start" ? "end" : "start", 'value-secondary-axis', axisConfig, labelConfig, canvasModel);
+    static getSecondaryValueAxis(defaultFormatter, orient, mainAxisPosition, axisConfig, labelConfig, canvasModel, scaleInfo) {
+        return this.getValueAxis(defaultFormatter, orient, mainAxisPosition === "start" ? "end" : "start", "value-secondary-axis", axisConfig, labelConfig, canvasModel, scaleInfo);
     }
-    static getValueAxis(defaultFormatter, orient, position, cssClass, axisConfig, labelConfig, canvasModel) {
-        var _a, _b, _c, _d;
+    static getValueAxis(defaultFormatter, orient, position, cssClass, axisConfig, labelConfig, canvasModel, scaleInfo) {
+        var _a, _b;
         return {
-            type: 'value',
+            type: "value",
             orient: AxisModel.getAxisOrient(AxisType.Value, orient, position),
             translate: {
                 translateX: AxisModel.getAxisTranslateX(AxisType.Value, orient, position, canvasModel),
@@ -55,23 +61,26 @@ export class AxisModel {
             ticks: axisConfig.ticks,
             labels: {
                 maxSize: labelConfig.maxSize.main,
-                position: 'straight',
+                position: "straight",
                 visible: true,
                 defaultTooltip: true,
                 showTick: showAllTicks,
-                linearTickStep: (_b = (_a = axisConfig.labels) === null || _a === void 0 ? void 0 : _a.stepSize) !== null && _b !== void 0 ? _b : (orient === "horizontal" ? MINIMAL_HORIZONTAL_STEP_SIZE : MINIMAL_VERTICAL_STEP_SIZE)
+                linearTickStep: this.getTickStep(orient, axisConfig),
+                tickAmountSettings: {
+                    policy: this.getTickAmountPolicy(orient, axisConfig, scaleInfo)
+                }
             },
             visibility: axisConfig.visibility,
             line: {
-                visible: (_d = (_c = axisConfig.line) === null || _c === void 0 ? void 0 : _c.visible) !== null && _d !== void 0 ? _d : DEFAULT_AXIS_LINE_VISIBLE
+                visible: (_b = (_a = axisConfig.line) === null || _a === void 0 ? void 0 : _a.visible) !== null && _b !== void 0 ? _b : DEFAULT_AXIS_LINE_VISIBLE
             },
             browserTooltip: {
-                format: value => defaultFormatter(value)
+                format: (value) => defaultFormatter(value)
             }
         };
     }
     static getAxisLength(chartOrientation, canvasModel) {
-        if (chartOrientation === 'horizontal') {
+        if (chartOrientation === "horizontal") {
             return canvasModel.getChartBlockHeight();
         }
         else {
@@ -79,28 +88,28 @@ export class AxisModel {
         }
     }
     static getAxisOrient(axisType, chartOrientation, axisPosition) {
-        if (chartOrientation === 'vertical') {
-            if (axisPosition === 'start')
-                return axisType === AxisType.Key ? 'top' : 'left';
-            return axisType === AxisType.Key ? 'bottom' : 'right';
+        if (chartOrientation === "vertical") {
+            if (axisPosition === "start")
+                return axisType === AxisType.Key ? "top" : "left";
+            return axisType === AxisType.Key ? "bottom" : "right";
         }
-        if (axisPosition === 'start')
-            return axisType === AxisType.Key ? 'left' : 'top';
-        return axisType === AxisType.Key ? 'right' : 'bottom';
+        if (axisPosition === "start")
+            return axisType === AxisType.Key ? "left" : "top";
+        return axisType === AxisType.Key ? "right" : "bottom";
     }
     static getAxisTranslateX(axisType, chartOrientation, axisPosition, canvasModel) {
         const orient = AxisModel.getAxisOrient(axisType, chartOrientation, axisPosition);
-        if (orient === 'top' || orient === 'left')
+        if (orient === "top" || orient === "left")
             return canvasModel.getMarginSide("left");
-        else if (orient === 'bottom')
+        else if (orient === "bottom")
             return canvasModel.getMarginSide("left");
         return canvasModel.getBlockSize().width - canvasModel.getMarginSide("right");
     }
     static getAxisTranslateY(axisType, chartOrientation, axisPosition, canvasModel) {
         const orient = AxisModel.getAxisOrient(axisType, chartOrientation, axisPosition);
-        if (orient === 'top' || orient === 'left')
+        if (orient === "top" || orient === "left")
             return canvasModel.getMarginSide("top");
-        else if (orient === 'bottom')
+        else if (orient === "bottom")
             return canvasModel.getBlockSize().height - canvasModel.getMarginSide("bottom");
         return canvasModel.getMarginSide("top");
     }
@@ -109,9 +118,10 @@ export class AxisModel {
         return this.service.getKeyAxisLabelPosition(canvasModel.getChartBlockWidth(), scopedDataLength, (_a = axisConfig === null || axisConfig === void 0 ? void 0 : axisConfig.labels) === null || _a === void 0 ? void 0 : _a.position);
     }
     static getLabelSize(labelMaxWidth, labelTexts) {
-        const LABEL_ELEMENT_HEIGHT_PX = 17;
         const ONE_UPPER_SYMBOL_WIDTH_PX = 8;
-        const longestLabelLength = labelTexts.length ? Math.max(...labelTexts.map(t => ModelHelper.getStringScore(t))) : 0;
+        const longestLabelLength = labelTexts.length
+            ? Math.max(...labelTexts.map((t) => ModelHelper.getStringScore(t)))
+            : 0;
         const longestLabelWidth = ONE_UPPER_SYMBOL_WIDTH_PX * longestLabelLength;
         return {
             height: LABEL_ELEMENT_HEIGHT_PX,
@@ -131,6 +141,19 @@ export class AxisModel {
         const roundedNumber = roundedFirstTwoDigits * Math.pow(10, valueStr.length - 2);
         return sign * roundedNumber;
     }
+    static getTickAmountPolicy(orient, axisConfig, scaleInfo) {
+        const axisLength = scaleInfo.range.end - scaleInfo.range.start;
+        const linearTickStep = this.getTickStep(orient, axisConfig);
+        let tickAmountPolicy;
+        if (Math.floor(axisLength / linearTickStep) > 2) {
+            tickAmountPolicy = { type: "amount", amount: Math.floor(axisLength / linearTickStep) };
+        }
+        else {
+            const roundedMaxValue = this.getRoundValue(max(scaleInfo.domain));
+            tickAmountPolicy = { type: "constant", values: [min(scaleInfo.domain), roundedMaxValue] };
+        }
+        return tickAmountPolicy;
+    }
     static getKeyAxisTranslateModel(chartOrientation, axisPosition, canvasModel, getZeroCoordinate) {
         let translateY;
         let translateX;
@@ -151,5 +174,9 @@ export class AxisModel {
             translateY
         };
     }
+    static getTickStep(orient, axisConfig) {
+        var _a, _b;
+        return ((_b = (_a = axisConfig.labels) === null || _a === void 0 ? void 0 : _a.stepSize) !== null && _b !== void 0 ? _b : (orient === "horizontal" ? MINIMAL_HORIZONTAL_STEP_SIZE : MINIMAL_VERTICAL_STEP_SIZE));
+    }
 }
 AxisModel.service = new AxisModelService();

package/lib/model/featuresModel/axisModelService.js

@@ -6,8 +6,8 @@ export class AxisModelService {
         }
         const minBandSize = 50;
         if (chartBlockWidth / scopedDataLength < minBandSize)
-            return 'rotated';
-        return 'straight';
+            return "rotated";
+        return "straight";
     }
 }
 export class AxisModelTickCalculator {

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

@@ -1,6 +1,6 @@
 import { DataLegendParams } from "../../dataManagerModel/dataManagerModel";
 import { LegendPosition } from "../../model";
-export declare type LegendItemsDirection = 'row' | 'column';
+export declare type LegendItemsDirection = "row" | "column";
 export interface LegendItemContentOptions {
     text: string;
     markerSize: {

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

@@ -6,16 +6,16 @@ export class LegendCanvasModel {
         document.body.append(legendWrapper);
         let amount = 0;
         for (let i = 0; i < items.length; i++) {
-            const itemWrapper = document.createElement('div');
-            const colorBlock = document.createElement('span');
-            const textBlock = document.createElement('span');
+            const itemWrapper = document.createElement("div");
+            const colorBlock = document.createElement("span");
+            const textBlock = document.createElement("span");
             itemWrapper.classList.add("legend-item");
-            if (position === 'bottom' || position === 'top') {
-                itemWrapper.classList.add('legend-item-inline');
-                textBlock.classList.add('legend-label-nowrap');
+            if (position === "bottom" || position === "top") {
+                itemWrapper.classList.add("legend-item-inline");
+                textBlock.classList.add("legend-label-nowrap");
             }
             else {
-                itemWrapper.classList.add('legend-item-row');
+                itemWrapper.classList.add("legend-item-row");
             }
             // colorBlock.classList.add(CLASSES.legendColor);
             colorBlock.style.display = "inline-block";
@@ -30,7 +30,7 @@ export class LegendCanvasModel {
             amount++;
             if (legendWrapper.offsetHeight > legendBlockHeight) {
                 itemWrapper.remove();
-                if (legendBlockHeight - legendWrapper.offsetHeight >= 15 && position !== 'bottom' && position !== 'top')
+                if (legendBlockHeight - legendWrapper.offsetHeight >= 15 && position !== "bottom" && position !== "top")
                     amount = amount; //TODO: remove
                 else
                     amount -= 1;
@@ -48,15 +48,15 @@ export class LegendCanvasModel {
         };
     }
     static getLegendWrapperEl(legendBlockWidth, itemsDirection) {
-        const legendWrapper = document.createElement('div');
-        legendWrapper.style.opacity = '0';
-        legendWrapper.style.position = 'absolute';
+        const legendWrapper = document.createElement("div");
+        legendWrapper.style.opacity = "0";
+        legendWrapper.style.position = "absolute";
         legendWrapper.style.display = "flex";
         if (itemsDirection === "column")
             legendWrapper.classList.add("legend-block-column");
         else
             legendWrapper.classList.add("legend-block-row", "legend-wrapper-with-wrap");
-        legendWrapper.style.maxWidth = legendBlockWidth + 'px';
+        legendWrapper.style.maxWidth = legendBlockWidth + "px";
         return legendWrapper;
     }
 }

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

@@ -31,11 +31,11 @@ export class LegendModel {
         };
     }
     static getLegendItemClass(itemsPosition) {
-        return itemsPosition === 'column' ? 'legend-item-row' : 'legend-item-inline';
+        return itemsPosition === "column" ? "legend-item-row" : "legend-item-inline";
     }
     static appendToGlobalMarginValuesLegendMargin(canvasModel, position, legendBlockModel) {
         const legendCoordinate = legendBlockModel.coordinate;
-        if (position === 'left' || position === 'right')
+        if (position === "left" || position === "right")
             canvasModel.increaseMarginSide(position, legendCoordinate[position].margin.left + legendCoordinate[position].margin.right);
         else
             canvasModel.increaseMarginSide(position, legendCoordinate[position].margin.top + legendCoordinate[position].margin.bottom);

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

@@ -12,7 +12,7 @@ export class LegendPolarMarginCalculator {
         const maxWidthNumber = parseInt(maxWidth);
         if (unit === "px")
             return maxWidthNumber;
-        return maxWidthNumber / 100 * blockWidth;
+        return (maxWidthNumber / 100) * blockWidth;
     }
     updateMarginObj(legendBlockModel, legendPosition, legendSize, canvasModel) {
         if (legendSize !== 0) {

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

@@ -10,13 +10,13 @@ export class TwoDimLegendModel {
         const canvasModel = modelInstance.canvasModel;
         const legendPosition = this.getLegendModel(legendOptions).position;
         modelInstance.canvasModel.legendCanvas.setPosition(legendPosition);
-        if (legendPosition !== 'off') {
+        if (legendPosition !== "off") {
             const legendItemInfo = this.configReader.getLegendItemInfo();
-            const legendSize = LegendCanvasModel.findElementsAmountByLegendSize(legendItemInfo.map(i => ({
+            const legendSize = LegendCanvasModel.findElementsAmountByLegendSize(legendItemInfo.map((i) => ({
                 text: i.text,
                 markerSize: Object.assign(Object.assign({}, styledElementValues.defaultLegendMarkerSizes), { widthPx: getWidthOfLegendMarkerByType(i.chartType) }),
                 wrapperSize: { marginRightPx: styledElementValues.legend.inlineItemWrapperMarginRightPx }
-            })), 'top', modelInstance.canvasModel.getBlockSize().width, legendBlockModel.static.maxLinesAmount * styledElementValues.legend.inlineLegendOneLineHeightPx).size.height;
+            })), "top", modelInstance.canvasModel.getBlockSize().width, legendBlockModel.static.maxLinesAmount * styledElementValues.legend.inlineLegendOneLineHeightPx).size.height;
             canvasModel.increaseMarginSide(legendPosition, legendSize);
             if (legendSize !== 0)
                 LegendModel.appendToGlobalMarginValuesLegendMargin(canvasModel, legendPosition, legendBlockModel);
@@ -25,8 +25,7 @@ export class TwoDimLegendModel {
     }
     getLegendModel(legendOptions) {
         var _a;
-        const position = legendOptions.show
-            ? (_a = legendOptions.position) !== null && _a !== void 0 ? _a : "top" : "off";
+        const position = legendOptions.show ? (_a = legendOptions.position) !== null && _a !== void 0 ? _a : "top" : "off";
         return {
             position
         };

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

@@ -1,12 +1,12 @@
-import { ScaleLinear, ScaleTime } from "d3-scale";
+import { ScaleLinear } from "d3-scale";
 import { ChartOrientation, DiscreteAxisOptions } from "../../../config/config";
 import { ScaleValueModel } from "../../model";
 import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
 export declare const keyAxisLabelVerticalLog = "keyAxisLabel_vertical_margin_log";
 export declare const keyAxisLabelHorizontalLog = "keyAxisLabel_horizontal_margin_log";
-interface ScaleInfo {
+export interface ScaleValueCalculatedInfo {
     scale: ScaleValueModel;
-    scaleFn: ScaleLinear<number, number, never> | ScaleTime<number, number, never>;
+    scaleFn: ScaleLinear<number, number, never>;
 }
 /**
  * Предназначен для получения нового scaleValue и уменьшения globalMargin, если ось ключей находится где-то внутри chartBlock, а не на его границе
@@ -15,6 +15,5 @@ export declare class ScaleAxisRecalcer {
     private generateScaleLinear;
     constructor(generateScaleLinear: () => ScaleValueModel);
     recalculateMargin(canvasModel: CanvasModel, chartOrientation: ChartOrientation, keyAxis: DiscreteAxisOptions): void;
-    getScaleValue(): ScaleInfo;
+    getScaleValue(): ScaleValueCalculatedInfo;
 }
-export {};

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

@@ -9,14 +9,12 @@ export class ScaleAxisRecalcer {
         this.generateScaleLinear = generateScaleLinear;
     }
     recalculateMargin(canvasModel, chartOrientation, keyAxis) {
-        const scaleValue = this.generateScaleLinear();
-        //TODO: rm import from engine
-        const scaleValueFn = Scale.getScaleValue(scaleValue);
-        const coordinateOnChartBlock = (keyAxis.position === "start"
+        const { scaleFn: scaleValueFn } = this.getScaleValue();
+        const coordinateOnChartBlock = keyAxis.position === "start"
             ? scaleValueFn(0)
             : (chartOrientation === "vertical"
                 ? canvasModel.getChartBlockHeight()
-                : canvasModel.getChartBlockWidth()) - scaleValueFn(0));
+                : canvasModel.getChartBlockWidth()) - scaleValueFn(0);
         const key = chartOrientation === "vertical" ? keyAxisLabelVerticalLog : keyAxisLabelHorizontalLog;
         const logInfo = canvasModel.marginService.getDataByKey(key);
         if (logInfo) {

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

@@ -1,14 +1,12 @@
 export function getResolvedDomain(domain, dataRows) {
-    return typeof domain === 'function'
-        ? domain({ data: dataRows })
-        : domain;
+    return typeof domain === "function" ? domain({ data: dataRows }) : domain;
 }
-export function getScaleLinearDomain(configDomain, dataRows, configOptions, valueGroup = 'main') {
+export function getScaleLinearDomain(configDomain, dataRows, configOptions, valueGroup = "main") {
     const calculator = new ScaleDomainCalculator();
     let domainPeekMin;
     let domainPeekMax;
     const resolvedConfigDomain = getResolvedDomain(configDomain, dataRows);
-    const charts = configOptions.charts.filter(chart => {
+    const charts = configOptions.charts.filter((chart) => {
         var _a;
         return ((_a = chart.data.valueGroup) !== null && _a !== void 0 ? _a : "main") === valueGroup;
     });
@@ -20,17 +18,17 @@ export function getScaleLinearDomain(configDomain, dataRows, configOptions, valu
         domainPeekMax = calculator.getScaleMaxValue(charts, dataRows);
     else
         domainPeekMax = resolvedConfigDomain.end;
-    if (configOptions.axis.key.position === 'start')
+    if (configOptions.axis.key.position === "start")
         return [domainPeekMin, domainPeekMax];
     return [domainPeekMax, domainPeekMin];
 }
 export class ScaleDomainCalculator {
     getScaleMinValue(charts, dataRows) {
         let min = 0;
-        charts.forEach(chart => {
-            dataRows.forEach(dataRow => {
+        charts.forEach((chart) => {
+            dataRows.forEach((dataRow) => {
                 let sumInRow = 0;
-                chart.data.valueFields.forEach(field => {
+                chart.data.valueFields.forEach((field) => {
                     if (chart.isSegmented && dataRow[field.name] < 0) {
                         sumInRow += dataRow[field.name];
                     }
@@ -45,10 +43,10 @@ export class ScaleDomainCalculator {
     }
     getScaleMaxValue(charts, dataRows) {
         let max = 0;
-        charts.forEach(chart => {
-            dataRows.forEach(dataRow => {
+        charts.forEach((chart) => {
+            dataRows.forEach((dataRow) => {
                 let sumInRow = 0;
-                chart.data.valueFields.forEach(field => {
+                chart.data.valueFields.forEach((field) => {
                     if (chart.isSegmented && dataRow[field.name] > 0)
                         sumInRow += dataRow[field.name];
                     else if (dataRow[field.name] > sumInRow)

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

@@ -1,5 +1,5 @@
 import { ScaleKeyModel, ScaleValueModel } from "../../model";
-import { MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions, ChartOrientation, MdtChartsDataRow } from "../../../config/config";
+import { MdtChartsTwoDimensionalOptions, MdtChartsDataRow } from "../../../config/config";
 import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
 import { TwoDimConfigReader } from "../../modelInstance/configReader";
 export declare enum ScaleType {
@@ -7,8 +7,12 @@ export declare enum ScaleType {
     Value = 1
 }
 export declare class ScaleModel {
-    getScaleKey(allowableKeys: string[], orient: ChartOrientation, canvasModel: CanvasModel, charts: MdtChartsTwoDimensionalChart[], bandLikeCharts: MdtChartsTwoDimensionalChart[]): ScaleKeyModel;
-    getScaleLinear(options: MdtChartsTwoDimensionalOptions, dataRows: MdtChartsDataRow[], canvasModel: CanvasModel, configReader?: TwoDimConfigReader): ScaleValueModel;
-    getScaleSecondaryLinear(options: MdtChartsTwoDimensionalOptions, dataRows: MdtChartsDataRow[], canvasModel: CanvasModel, configReader?: TwoDimConfigReader): ScaleValueModel;
+    private readonly options;
+    private readonly canvasModel;
+    constructor(options: MdtChartsTwoDimensionalOptions, canvasModel: CanvasModel);
+    getScaleKey(allowableKeys: string[]): ScaleKeyModel;
+    getScaleLinear(dataRows: MdtChartsDataRow[], configReader?: TwoDimConfigReader): ScaleValueModel;
+    getScaleSecondaryLinear(dataRows: MdtChartsDataRow[], configReader?: TwoDimConfigReader): ScaleValueModel;
+    private getChartsByTypes;
     private getScaleKeyType;
 }