mdt-charts 1.27.1 → 1.27.3

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

@@ -6,44 +6,52 @@ export var ScaleType;
     ScaleType[ScaleType["Value"] = 1] = "Value";
 })(ScaleType || (ScaleType = {}));
 export class ScaleModel {
-    getScaleKey(allowableKeys, orient, canvasModel, charts, bandLikeCharts) {
+    constructor(options, canvasModel) {
+        this.options = options;
+        this.canvasModel = canvasModel;
+    }
+    getScaleKey(allowableKeys) {
+        const bandLikeCharts = this.getChartsByTypes(this.options.charts, ["bar", "dot"]);
         return {
             domain: allowableKeys,
             range: {
                 start: 0,
-                end: getScaleKeyRangePeek(orient, canvasModel)
+                end: getScaleKeyRangePeek(this.options.orientation, this.canvasModel)
             },
-            type: this.getScaleKeyType(charts),
+            type: this.getScaleKeyType(this.options.charts),
             elementsAmount: getElementsAmountForScale(bandLikeCharts)
         };
     }
-    getScaleLinear(options, dataRows, canvasModel, configReader) {
+    getScaleLinear(dataRows, configReader) {
         var _a;
         return {
-            domain: getScaleLinearDomain(options.axis.value.domain, dataRows, options),
+            domain: getScaleLinearDomain(this.options.axis.value.domain, dataRows, this.options),
             range: {
                 start: 0,
-                end: getScaleValueRangePeek(options.orientation, canvasModel)
+                end: getScaleValueRangePeek(this.options.orientation, this.canvasModel)
             },
             type: "linear",
             formatter: (_a = configReader === null || configReader === void 0 ? void 0 : configReader.getAxisLabelFormatter()) !== null && _a !== void 0 ? _a : null
         };
     }
-    getScaleSecondaryLinear(options, dataRows, canvasModel, configReader) {
+    getScaleSecondaryLinear(dataRows, configReader) {
         var _a;
         return {
-            domain: getScaleLinearDomain(options.axis.value.domain, dataRows, options, 'secondary'),
+            domain: getScaleLinearDomain(this.options.axis.value.domain, dataRows, this.options, "secondary"),
             range: {
                 start: 0,
-                end: getScaleValueRangePeek(options.orientation, canvasModel)
+                end: getScaleValueRangePeek(this.options.orientation, this.canvasModel)
             },
             type: "linear",
             formatter: (_a = configReader === null || configReader === void 0 ? void 0 : configReader.getSecondaryAxisLabelFormatter()) !== null && _a !== void 0 ? _a : null
         };
     }
+    getChartsByTypes(charts, types) {
+        return charts.filter((chart) => types.includes(chart.type));
+    }
     getScaleKeyType(charts) {
-        if (charts.some((chart) => chart.type === 'bar' || chart.type === 'dot'))
-            return 'band';
-        return 'point';
+        if (charts.some((chart) => chart.type === "bar" || chart.type === "dot"))
+            return "band";
+        return "point";
     }
 }

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

@@ -1,10 +1,10 @@
 export function getScaleKeyRangePeek(chartOrientation, canvasModel) {
-    if (chartOrientation === 'vertical')
+    if (chartOrientation === "vertical")
         return canvasModel.getChartBlockWidth();
     return canvasModel.getChartBlockHeight();
 }
 export function getScaleValueRangePeek(chartOrientation, canvasModel) {
-    if (chartOrientation === 'vertical')
+    if (chartOrientation === "vertical")
         return canvasModel.getChartBlockHeight();
     return canvasModel.getChartBlockWidth();
 }
@@ -12,12 +12,12 @@ export function getElementsAmountForScale(bandLikeCharts) {
     if (bandLikeCharts.length === 0)
         return 1;
     let barAmounts = {};
-    bandLikeCharts.forEach(chart => {
+    bandLikeCharts.forEach((chart) => {
         if (!barAmounts[chart.type])
             barAmounts[chart.type] = 0;
-        if (chart.type === 'dot')
+        if (chart.type === "dot")
             barAmounts[chart.type] = 1;
-        if (chart.type === 'bar') {
+        if (chart.type === "bar") {
             if (chart.isSegmented)
                 barAmounts[chart.type] += 1;
             else

package/lib/model/featuresModel/tooltipModel.js

@@ -1,7 +1,7 @@
 export class TooltipModel {
     static getTooltipModel(options) {
         return {
-            position: (options === null || options === void 0 ? void 0 : options.position) || 'followCursor'
+            position: (options === null || options === void 0 ? void 0 : options.position) || "followCursor"
         };
     }
 }

package/lib/model/featuresModel/valueLabelsModel/valueLabelsModel.js

@@ -8,9 +8,9 @@ export class ValueLabelCoordinateCalculator {
     }
     getValueLabelY(scaledValue) {
         switch (this.keyAxisOrient) {
-            case 'bottom':
+            case "bottom":
                 return scaledValue - this.offsetSizePx + this.margin.top;
-            case 'top':
+            case "top":
                 return scaledValue + this.offsetSizePx + this.margin.top;
             default:
                 return scaledValue + this.margin.top;
@@ -18,9 +18,9 @@ export class ValueLabelCoordinateCalculator {
     }
     getValueLabelX(scaledValue) {
         switch (this.keyAxisOrient) {
-            case 'right':
+            case "right":
                 return scaledValue - this.offsetSizePx + this.margin.left;
-            case 'left':
+            case "left":
                 return scaledValue + this.offsetSizePx + this.margin.left;
             default:
                 return scaledValue + this.margin.left;
@@ -30,7 +30,7 @@ export class ValueLabelCoordinateCalculator {
 export function calculateValueLabelAlignment(keyAxisOrient, positionMode) {
     if (!positionMode || positionMode === "after") {
         switch (keyAxisOrient) {
-            case 'top':
+            case "top":
                 return { dominantBaseline: "hanging", textAnchor: "middle" };
             case "bottom":
                 return { dominantBaseline: "auto", textAnchor: "middle" };

package/lib/model/helpers/modelHelper.js

@@ -19,15 +19,17 @@ export class ModelHelper {
     static getStringScore(word) {
         // lower case letter width ~ 0.8 from upper case width.
         // Number width == lower case letter width
-        const fontSize = this.getBaseFontSize('--chart-base-font-size');
+        const fontSize = this.getBaseFontSize("--chart-base-font-size");
         let score = 0;
-        const upperLetterScore = fontSize / 10;
-        const lowerLetterScore = fontSize / 14;
+        const upperLetterScore = fontSize / 9;
+        const lowerLetterScore = fontSize / 13;
         const digitScore = fontSize / 15;
         const otherSymbolScore = fontSize / 23;
         const specialSmallSymbols = [",", ".", " "];
         for (let i = 0; i < word.length; i++) {
-            if (parseFloat(word[i]).toString() !== word[i] && !specialSmallSymbols.includes(word[i]) && word[i].trim().length > 0) {
+            if (parseFloat(word[i]).toString() !== word[i] &&
+                !specialSmallSymbols.includes(word[i]) &&
+                word[i].trim().length > 0) {
                 if (word[i].toUpperCase() === word[i])
                     score += upperLetterScore;
                 else

package/lib/model/helpers/twoDimensionalModelHelper.d.ts

@@ -3,7 +3,7 @@ import { GradientDef, MarkDotDatumItem, Orient, TwoDimensionalChartModel, TwoDim
 import { CanvasModel } from "../modelInstance/canvasModel/canvasModel";
 export declare class TwoDimensionalModelHelper {
     static shouldMarkerShow(chart: MdtChartsTwoDimensionalChart, dataRows: MdtChartsDataRow[], valueFieldName: string, currentRow: MarkDotDatumItem, keyFieldName: string): boolean;
-    static getGradientDefs(charts: TwoDimensionalChartModel[], keyAxisOrient: Orient, chartOrient: ChartOrientation): GradientDef[];
+    static getGradientDefs(charts: TwoDimensionalChartModel[], keyAxisOrient: Orient, chartOrient: ChartOrientation, chartBlockId: number): GradientDef[];
     private static getGradientItems;
     private static calculateOpacityItem;
     private static getGradientItemColor;

package/lib/model/helpers/twoDimensionalModelHelper.js

@@ -4,33 +4,34 @@ export class TwoDimensionalModelHelper {
     static shouldMarkerShow(chart, dataRows, valueFieldName, currentRow, keyFieldName) {
         if (chart.markers.show || dataRows.length === 1)
             return true;
-        const rowIndex = dataRows.findIndex(row => row[keyFieldName] === currentRow[keyFieldName]);
+        const rowIndex = dataRows.findIndex((row) => row[keyFieldName] === currentRow[keyFieldName]);
         if (rowIndex === -1)
             return false;
         const isFirst = rowIndex === 0;
         const isLast = rowIndex === dataRows.length - 1;
         const previousRow = dataRows[rowIndex - 1];
         const nextRow = dataRows[rowIndex + 1];
-        const hasNullNeighborsRows = !isFirst && !isLast &&
-            (previousRow === null || previousRow === void 0 ? void 0 : previousRow[valueFieldName]) === null && (nextRow === null || nextRow === void 0 ? void 0 : nextRow[valueFieldName]) === null;
-        return (isFirst && (nextRow === null || nextRow === void 0 ? void 0 : nextRow[valueFieldName]) === null) || (isLast && (previousRow === null || previousRow === void 0 ? void 0 : previousRow[valueFieldName]) === null) || hasNullNeighborsRows;
+        const hasNullNeighborsRows = !isFirst && !isLast && (previousRow === null || previousRow === void 0 ? void 0 : previousRow[valueFieldName]) === null && (nextRow === null || nextRow === void 0 ? void 0 : nextRow[valueFieldName]) === null;
+        return ((isFirst && (nextRow === null || nextRow === void 0 ? void 0 : nextRow[valueFieldName]) === null) ||
+            (isLast && (previousRow === null || previousRow === void 0 ? void 0 : previousRow[valueFieldName]) === null) ||
+            hasNullNeighborsRows);
     }
-    static getGradientDefs(charts, keyAxisOrient, chartOrient) {
+    static getGradientDefs(charts, keyAxisOrient, chartOrient, chartBlockId) {
         let gradients = [];
         charts.forEach((chart) => {
             var _a;
-            if (chart.type === 'area' && chart.areaViewOptions.fill.type === 'gradient') {
+            if (chart.type === "area" && chart.areaViewOptions.fill.type === "gradient") {
                 (_a = chart.style.elementColors) === null || _a === void 0 ? void 0 : _a.forEach((elementColor, subIndex) => {
-                    const gradientId = getGradientId(chart.index, subIndex);
+                    const gradientId = getGradientId(chart.index, subIndex, chartBlockId);
                     gradients.push({
                         id: gradientId,
                         position: {
                             x1: 0,
                             y1: 0,
-                            x2: chartOrient === 'horizontal' ? 1 : 0,
-                            y2: chartOrient === 'horizontal' ? 0 : 1,
+                            x2: chartOrient === "horizontal" ? 1 : 0,
+                            y2: chartOrient === "horizontal" ? 0 : 1
                         },
-                        items: this.getGradientItems(gradientId, elementColor, keyAxisOrient),
+                        items: this.getGradientItems(gradientId, elementColor, keyAxisOrient)
                     });
                 });
             }
@@ -38,7 +39,7 @@ export class TwoDimensionalModelHelper {
         return gradients;
     }
     static getGradientItems(gradientId, elementColor, keyAxisOrient) {
-        return [0, 1].map(itemIndex => ({
+        return [0, 1].map((itemIndex) => ({
             id: gradientId + `-item-${itemIndex}`,
             color: this.getGradientItemColor(itemIndex, keyAxisOrient, elementColor),
             offset: itemIndex,
@@ -48,16 +49,15 @@ export class TwoDimensionalModelHelper {
     static calculateOpacityItem(itemIndex, orientation) {
         const maxOpacity = 0.3;
         const minOpacity = 0;
-        if (orientation === 'bottom' || orientation === 'right')
+        if (orientation === "bottom" || orientation === "right")
             return itemIndex === 0 ? maxOpacity : minOpacity;
         else
             return itemIndex === 0 ? minOpacity : maxOpacity;
     }
-    ;
     static getGradientItemColor(itemIndex, orientation, elementColor) {
         const maxColor = elementColor;
         const minColor = "white";
-        if (orientation === 'bottom' || orientation === 'right')
+        if (orientation === "bottom" || orientation === "right")
             return itemIndex === 0 ? maxColor : minColor;
         else
             return itemIndex === 0 ? minColor : maxColor;
@@ -68,36 +68,36 @@ export class TwoDimensionalModelHelper {
         const chartBlockConfig = {
             vertical: {
                 left: {
-                    mode: 'shift',
+                    mode: "shift",
                     hasCollision: blockSidesOptions.hasCollisionLeft,
                     shiftCoordinate: blockSidesOptions.shiftRight
                 },
                 right: {
-                    mode: 'shift',
+                    mode: "shift",
                     hasCollision: blockSidesOptions.hasCollisionRight,
                     shiftCoordinate: blockSidesOptions.shiftLeft
                 },
                 top: {
-                    mode: 'none'
+                    mode: "none"
                 },
                 bottom: {
-                    mode: 'none'
+                    mode: "none"
                 }
             },
             horizontal: {
                 left: {
-                    mode: 'none'
+                    mode: "none"
                 },
                 right: {
-                    mode: 'none'
+                    mode: "none"
                 },
                 top: {
-                    mode: 'shift',
+                    mode: "shift",
                     hasCollision: blockSidesOptions.hasCollisionTop,
                     shiftCoordinate: blockSidesOptions.shiftBottom
                 },
                 bottom: {
-                    mode: 'shift',
+                    mode: "shift",
                     hasCollision: blockSidesOptions.hasCollisionBottom,
                     shiftCoordinate: blockSidesOptions.shiftTop
                 }
@@ -106,7 +106,7 @@ export class TwoDimensionalModelHelper {
         return {
             collision: {
                 otherValueLables: (_b = (_a = valueLabels === null || valueLabels === void 0 ? void 0 : valueLabels.collision) === null || _a === void 0 ? void 0 : _a.otherValueLabels) !== null && _b !== void 0 ? _b : {
-                    mode: 'none'
+                    mode: "none"
                 },
                 chartBlock: chartBlockConfig[chartOrientation]
             },

package/lib/model/helpers/unitsReader.js

@@ -6,7 +6,7 @@ export class UnitsReader {
     }
     getLastUnitFromString(value, units) {
         let resultUnit = null;
-        units.forEach(unit => {
+        units.forEach((unit) => {
             if (value.endsWith(unit))
                 resultUnit = unit;
         });

package/lib/model/margin/marginModel.js

@@ -11,7 +11,7 @@ export class MarginModel {
         const canvasModel = modelInstance.canvasModel;
         canvasModel.initMargin(Object.assign({}, this.designerConfig.canvas.chartBlockMargin));
         this.recalcMarginByTitle(canvasModel);
-        if (this.config.options.type === '2d') {
+        if (this.config.options.type === "2d") {
             this.twoDimModel.recalcMargin(otherComponents, modelInstance);
         }
     }

package/lib/model/margin/twoDim/twoDimMarginModel.d.ts

@@ -17,4 +17,5 @@ export declare class TwoDimMarginModel {
     private recalcHorizontalMarginByAxisLabelWidth;
     private recalcMarginBySecondaryAxisLabelSize;
     private recalcVerticalMarginWithValueLabelsOn;
+    private getValueAxisLabels;
 }

package/lib/model/margin/twoDim/twoDimMarginModel.js

@@ -1,9 +1,11 @@
-import { AxisModel } from "../../featuresModel/axisModel";
+import { AxisModel, LABEL_ELEMENT_HEIGHT_PX } from "../../featuresModel/axisModel";
 import { TwoDimLegendModel } from "../../featuresModel/legendModel/twoDimLegendModel";
 import { keyAxisLabelHorizontalLog, keyAxisLabelVerticalLog } from "../../featuresModel/scaleModel/scaleAxisRecalcer";
 import { AxisType } from "../../modelBuilder";
 import { TwoDimensionalModel } from "../../notations/twoDimensionalModel";
 import { OFFSET_SIZE_PX } from "../../featuresModel/valueLabelsModel/valueLabelsModel";
+import { ScaleModel } from "../../featuresModel/scaleModel/scaleModel";
+import { Scale } from "../../../engine/features/scale/scale";
 export const AXIS_HORIZONTAL_LABEL_PADDING = 12;
 export const AXIS_VERTICAL_LABEL_PADDING = 8;
 export class TwoDimMarginModel {
@@ -15,12 +17,12 @@ export class TwoDimMarginModel {
     recalcMargin(otherComponents, modelInstance) {
         const canvasModel = modelInstance.canvasModel;
         this.twoDimLegendModel.recalcMarginWith2DLegend(modelInstance, otherComponents.legendBlock, this.configReader.options.legend);
+        this.recalcVerticalMarginByAxisLabelHeight(LABEL_ELEMENT_HEIGHT_PX, canvasModel);
         const labelSize = this.getMaxLabelSize(modelInstance);
-        this.recalcVerticalMarginByAxisLabelHeight(labelSize, canvasModel);
         // Если встроенный лейбл показывает ключи, то лейблы оси ключей не показываются
         // При этом все графики должны иметь: embeddedLabels = 'key'
-        // И все графики должны быть типа bar. 
-        const showingFlag = this.configReader.options.type === '2d'
+        // И все графики должны быть типа bar.
+        const showingFlag = this.configReader.options.type === "2d"
             ? !TwoDimensionalModel.getChartsEmbeddedLabelsFlag(this.configReader.options.charts, this.configReader.options.orientation)
             : true;
         this.recalcHorizontalMarginByAxisLabelWidth(labelSize, canvasModel, showingFlag);
@@ -28,17 +30,19 @@ export class TwoDimMarginModel {
             const secondaryLabelSize = this.getMaxLabelSizeSecondary(modelInstance);
             this.recalcMarginBySecondaryAxisLabelSize(secondaryLabelSize, canvasModel);
         }
-        if (this.configReader.areValueLabelsOn() && this.configReader.areValueLabelsNeedIncreaseMargin() && this.configReader.options.orientation === 'vertical') {
+        if (this.configReader.areValueLabelsOn() &&
+            this.configReader.areValueLabelsNeedIncreaseMargin() &&
+            this.configReader.options.orientation === "vertical") {
             this.recalcVerticalMarginWithValueLabelsOn(canvasModel);
         }
     }
     recalcMarginByVerticalAxisLabel(modelInstance) {
-        if (this.configReader.options.orientation === 'vertical') {
+        if (this.configReader.options.orientation === "vertical") {
             const dataModel = modelInstance.dataModel;
             const axisLabelSize = AxisModel.getLabelSize(this.designerConfig.canvas.axisLabel.maxSize.main, dataModel.getAllowableKeys());
             const axisConfig = AxisModel.getKeyAxisLabelPosition(modelInstance.canvasModel, dataModel.getAllowableKeys().length, this.configReader.options.axis.key);
-            const marginOrient = this.configReader.options.axis.key.position === 'end' ? 'bottom' : 'top';
-            if (axisConfig === 'rotated') {
+            const marginOrient = this.configReader.options.axis.key.position === "end" ? "bottom" : "top";
+            if (axisConfig === "rotated") {
                 modelInstance.canvasModel.decreaseMarginSide(marginOrient, axisLabelSize.height);
                 modelInstance.canvasModel.increaseMarginSide(marginOrient, axisLabelSize.width, keyAxisLabelVerticalLog);
             }
@@ -47,44 +51,38 @@ export class TwoDimMarginModel {
     getMaxLabelSize(modelInstance) {
         const keyAxisOrient = AxisModel.getAxisOrient(AxisType.Key, this.configReader.options.orientation, this.configReader.options.axis.key.position);
         let labelsTexts;
-        if (keyAxisOrient === 'left' || keyAxisOrient === 'right') {
+        if (keyAxisOrient === "left" || keyAxisOrient === "right") {
             labelsTexts = modelInstance.dataModel.repository.getValuesByKeyField();
         }
         else {
-            labelsTexts = this.configReader.getBiggestValueAndDecremented(modelInstance.dataModel.repository)
-                .map(v => this.configReader.getAxisLabelFormatter()(v).toString());
+            const scaleModel = new ScaleModel(this.configReader.options, modelInstance.canvasModel).getScaleLinear(modelInstance.dataModel.repository.getRawRows(), this.configReader);
+            labelsTexts = this.getValueAxisLabels(scaleModel, modelInstance).map((v) => this.configReader.getAxisLabelFormatter()(v).toString());
         }
         return AxisModel.getLabelSize(this.designerConfig.canvas.axisLabel.maxSize.main, labelsTexts);
     }
     getMaxLabelSizeSecondary(modelInstance) {
-        const keyAxisOrient = AxisModel.getAxisOrient(AxisType.Key, this.configReader.options.orientation, this.configReader.options.axis.key.position);
-        let labelsTexts;
-        if (keyAxisOrient === 'left' || keyAxisOrient === 'right') {
-            labelsTexts = modelInstance.dataModel.repository.getValuesByKeyField();
-        }
-        else {
-            labelsTexts = this.configReader.getBiggestValueAndDecrementedSecondary(modelInstance.dataModel.repository)
-                .map(v => this.configReader.getSecondaryAxisLabelFormatter()(v).toString());
-        }
+        const scaleModel = new ScaleModel(this.configReader.options, modelInstance.canvasModel).getScaleSecondaryLinear(modelInstance.dataModel.repository.getRawRows(), this.configReader);
+        const labelsTexts = this.getValueAxisLabels(scaleModel, modelInstance).map((v) => this.configReader.getSecondaryAxisLabelFormatter()(v).toString());
         return AxisModel.getLabelSize(this.designerConfig.canvas.axisLabel.maxSize.main, labelsTexts);
     }
-    recalcVerticalMarginByAxisLabelHeight(labelSize, canvasModel) {
+    recalcVerticalMarginByAxisLabelHeight(labelHeight, canvasModel) {
         const keyAxisOrient = AxisModel.getAxisOrient(AxisType.Key, this.configReader.options.orientation, this.configReader.options.axis.key.position);
         const valueAxisOrient = AxisModel.getAxisOrient(AxisType.Value, this.configReader.options.orientation, this.configReader.options.axis.value.position);
-        if ((keyAxisOrient === 'bottom' || keyAxisOrient === 'top')) {
-            if (this.configReader.options.axis.key.visibility)
-                canvasModel.increaseMarginSide(keyAxisOrient, labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING, keyAxisLabelVerticalLog);
-        }
+        if ((keyAxisOrient === "bottom" || keyAxisOrient === "top") && this.configReader.options.axis.key.visibility)
+            canvasModel.increaseMarginSide(keyAxisOrient, labelHeight + AXIS_HORIZONTAL_LABEL_PADDING, keyAxisLabelVerticalLog);
         else if (this.configReader.options.axis.value.visibility)
-            canvasModel.increaseMarginSide(valueAxisOrient, labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING);
+            canvasModel.increaseMarginSide(valueAxisOrient, labelHeight + AXIS_HORIZONTAL_LABEL_PADDING);
     }
     recalcHorizontalMarginByAxisLabelWidth(labelSize, canvasModel, isShow) {
         const keyAxisOrient = AxisModel.getAxisOrient(AxisType.Key, this.configReader.options.orientation, this.configReader.options.axis.key.position);
         const valueAxisOrient = AxisModel.getAxisOrient(AxisType.Value, this.configReader.options.orientation, this.configReader.options.axis.value.position);
-        if ((keyAxisOrient === 'left' || keyAxisOrient === 'right') && isShow && this.configReader.options.axis.key.visibility) {
+        if ((keyAxisOrient === "left" || keyAxisOrient === "right") &&
+            isShow &&
+            this.configReader.options.axis.key.visibility) {
             canvasModel.increaseMarginSide(keyAxisOrient, labelSize.width + AXIS_VERTICAL_LABEL_PADDING, keyAxisLabelHorizontalLog);
         }
-        else if ((valueAxisOrient === 'left' || valueAxisOrient === 'right') && this.configReader.options.axis.value.visibility) {
+        else if ((valueAxisOrient === "left" || valueAxisOrient === "right") &&
+            this.configReader.options.axis.value.visibility) {
             canvasModel.increaseMarginSide(valueAxisOrient, labelSize.width + AXIS_VERTICAL_LABEL_PADDING);
         }
     }
@@ -114,4 +112,16 @@ export class TwoDimMarginModel {
         };
         canvasModel.increaseMarginSide(axisMarginMapping[keyAxisOrient], valueLabelFontSize + OFFSET_SIZE_PX);
     }
+    getValueAxisLabels(scaleModel, modelInstance) {
+        const scale = Scale.getScaleValue(scaleModel);
+        const ticksPolicy = AxisModel.getTickAmountPolicy(this.configReader.options.orientation, this.configReader.options.axis.value, scaleModel);
+        let outputValues;
+        if (ticksPolicy.type === "constant")
+            outputValues = ticksPolicy.values;
+        else if (ticksPolicy.type === "amount")
+            outputValues = scale.ticks(ticksPolicy.amount);
+        else
+            outputValues = this.configReader.getBiggestValueAndDecremented(modelInstance.dataModel.repository);
+        return outputValues;
+    }
 }

package/lib/model/model.d.ts

@@ -4,7 +4,7 @@ import { BoundingRect } from "../engine/features/valueLabelsCollision/valueLabel
 declare type AxisType = "key" | "value";
 export declare type Orient = "top" | "bottom" | "left" | "right";
 export declare type ScaleKeyType = "band" | "point";
-export declare type ScaleValueType = "linear" | "datetime";
+export declare type ScaleValueType = "linear";
 export declare type LegendPosition = "off" | "top" | "bottom" | "left" | "right";
 export declare type EmbeddedLabelTypeModel = "none" | "key" | "value";
 export declare type DataOptions = {
@@ -162,7 +162,20 @@ export interface AxisLabelModel {
     defaultTooltip: boolean;
     showTick: ShowTickFn;
     linearTickStep: number;
+    tickAmountSettings: TickAmountModel;
 }
+interface TickAmountModel {
+    policy: TickAmountPolicy;
+}
+export declare type TickAmountPolicy = {
+    type: "auto";
+} | {
+    type: "amount";
+    amount: number;
+} | {
+    type: "constant";
+    values: number[];
+};
 export interface AdditionalElementsOptions {
     gridLine: GridLineOptions;
 }
@@ -298,7 +311,7 @@ export interface TwoDimensionalChartLegendBarModel {
     borderRadius: BarBorderRadius;
     width: number;
 }
-export interface TwoDimensionalChartLegendLineModel extends Omit<TwoDimensionalLineLikeChartViewModel, 'renderForKey'> {
+export interface TwoDimensionalChartLegendLineModel extends Omit<TwoDimensionalLineLikeChartViewModel, "renderForKey"> {
     length: number;
 }
 interface TwoDimensionalLineLikeChartModel {
@@ -387,9 +400,9 @@ export interface MarkersOptions {
     show: MarkersOptionsShow;
     styles: MarkersStyleOptions;
 }
-export declare type MarkDotDatumItem = MdtChartsDataRow | {
+export declare type MarkDotDatumItem = MdtChartsDataRow | ({
     "1": any;
-} & Array<number>;
+} & Array<number>);
 export declare type MarkersOptionsShow = (options: {
     row: MarkDotDatumItem;
     valueFieldName: string;

package/lib/model/modelBuilder.d.ts

@@ -1,6 +1,6 @@
-import { MdtChartsConfig, MdtChartsDataSource } from '../config/config';
-import { Model } from './model';
-import { DesignerConfig } from '../designer/designerConfig';
+import { MdtChartsConfig, MdtChartsDataSource } from "../config/config";
+import { Model } from "./model";
+import { DesignerConfig } from "../designer/designerConfig";
 export declare enum AxisType {
     Key = 0,
     Value = 1
@@ -23,5 +23,5 @@ export declare const styledElementValues: {
         inlineDynamicItemWrapperMarginRightPx: number;
     };
 };
-export declare function assembleModel(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig): Model;
+export declare function assembleModel(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig, chartBlockVersion: number): Model;
 export declare function getPreparedData(model: Model, data: MdtChartsDataSource, config: MdtChartsConfig): MdtChartsDataSource;

package/lib/model/modelBuilder.js

@@ -1,11 +1,11 @@
-import { MarginModel } from './margin/marginModel';
-import { TwoDimensionalModel } from './notations/twoDimensionalModel';
-import { PolarModel } from './notations/polar/polarModel';
-import { DataManagerModel } from './dataManagerModel/dataManagerModel';
-import { OtherComponentsModel } from './featuresModel/otherComponents';
-import { ConfigValidator } from './configsValidator/configValidator';
-import { ModelInstance } from './modelInstance/modelInstance';
-import { TwoDimConfigReader } from './modelInstance/configReader';
+import { MarginModel } from "./margin/marginModel";
+import { TwoDimensionalModel } from "./notations/twoDimensionalModel";
+import { PolarModel } from "./notations/polar/polarModel";
+import { DataManagerModel } from "./dataManagerModel/dataManagerModel";
+import { OtherComponentsModel } from "./featuresModel/otherComponents";
+import { ConfigValidator } from "./configsValidator/configValidator";
+import { ModelInstance } from "./modelInstance/modelInstance";
+import { TwoDimConfigReader } from "./modelInstance/configReader";
 import { TitleConfigReader } from "./modelInstance/titleConfigReader";
 export var AxisType;
 (function (AxisType) {
@@ -13,10 +13,10 @@ export var AxisType;
     AxisType[AxisType["Value"] = 1] = "Value";
 })(AxisType || (AxisType = {}));
 export const CLASSES = {
-    dataLabel: 'data-label',
-    legendLabel: 'legend-label',
-    legendColor: 'legend-circle',
-    legendItem: 'legend-item',
+    dataLabel: "data-label",
+    legendLabel: "legend-label",
+    legendColor: "legend-circle",
+    legendItem: "legend-item"
 };
 export const styledElementValues = {
     defaultLegendMarkerSizes: {
@@ -32,7 +32,8 @@ export const styledElementValues = {
 };
 function getBlockCanvas(config, modelInstance) {
     const emptyBlockParams = { width: 0, height: 0 };
-    const size = ConfigValidator.validateCanvasSize(modelInstance.canvasModel.getBlockSize()) ? Object.assign({}, modelInstance.canvasModel.getBlockSize()) : emptyBlockParams;
+    const size = ConfigValidator.validateCanvasSize(modelInstance.canvasModel.getBlockSize())
+        ? Object.assign({}, modelInstance.canvasModel.getBlockSize()) : emptyBlockParams;
     return {
         size,
         cssClass: config.canvas.class
@@ -45,10 +46,10 @@ function getChartBlockModel(modelInstance) {
 }
 function getOptions(config, designerConfig, modelInstance) {
     //TODO: migrate to polymorphism
-    if (config.options.type === '2d') {
+    if (config.options.type === "2d") {
         return TwoDimensionalModel.getOptions(new TwoDimConfigReader(config, designerConfig), designerConfig, modelInstance);
     }
-    else if (config.options.type === 'polar') {
+    else if (config.options.type === "polar") {
         return PolarModel.getOptions(config.options, designerConfig, modelInstance);
     }
 }
@@ -66,8 +67,8 @@ function getDataFormat(designerConfig) {
 function getTransitions(designerConfig) {
     return designerConfig.transitions;
 }
-export function assembleModel(config, data, designerConfig) {
-    const modelInstance = ModelInstance.create(config, data, designerConfig);
+export function assembleModel(config, data, designerConfig, chartBlockVersion) {
+    const modelInstance = ModelInstance.create(config, data, designerConfig, chartBlockVersion);
     if (!data || Object.keys(data).length === 0)
         return {
             blockCanvas: getBlockCanvas(config, modelInstance),
@@ -84,7 +85,7 @@ export function assembleModel(config, data, designerConfig) {
     const marginModel = new MarginModel(designerConfig, config);
     marginModel.initMargin(otherComponents, modelInstance);
     DataManagerModel.initDataScope(config, data, designerConfig, otherComponents.legendBlock, modelInstance);
-    if (config.options.type === '2d' && config.options.axis.key.visibility)
+    if (config.options.type === "2d" && config.options.axis.key.visibility)
         marginModel.recalcMarginByVerticalAxisLabel(modelInstance);
     const blockCanvas = getBlockCanvas(config, modelInstance);
     const chartBlock = getChartBlockModel(modelInstance);

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

@@ -21,6 +21,6 @@ export class MarginModelService {
         return (_a = this.findLogByKey(key)) === null || _a === void 0 ? void 0 : _a.data;
     }
     findLogByKey(key) {
-        return this.log.find(l => l.key === key);
+        return this.log.find((l) => l.key === key);
     }
 }

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

@@ -0,0 +1,5 @@
+export declare class ChartBlockVersion {
+    private readonly versionNumber;
+    constructor(versionNumber: number);
+    getVersionNumber(): number;
+}

package/lib/model/modelInstance/chartBlockVersion/chartBlockVersion.js

@@ -0,0 +1,8 @@
+export class ChartBlockVersion {
+    constructor(versionNumber) {
+        this.versionNumber = versionNumber;
+    }
+    getVersionNumber() {
+        return this.versionNumber;
+    }
+}