mdt-charts 1.33.2 → 1.34.0

package/lib/model/featuresModel/otherComponents.js

@@ -1,10 +1,9 @@
 import { LegendModel } from "./legendModel/legendModel";
-import { TitleModel } from "./titleModel";
 import { TooltipCanvasModel } from "./tooltipModel/tooltipCanvasModel";
 export class OtherComponentsModel {
     static getOtherComponentsModel(dependencies, modelInstance) {
         const canvasModel = modelInstance.canvasModel;
-        canvasModel.titleCanvas.init(TitleModel.getTitleModel(dependencies.titleConfig));
+        canvasModel.titleCanvas.init(dependencies.titleConfig);
         return {
             legendBlock: LegendModel.getBaseLegendBlockModel(canvasModel, dependencies.legendConfig),
             titleBlock: canvasModel.titleCanvas.getModel(),

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

@@ -1,7 +1,8 @@
 import { ScaleKeyModel, ScaleValueModel } from "../../model";
 import { MdtChartsTwoDimensionalOptions, MdtChartsDataRow } from "../../../config/config";
 import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
-import { TwoDimConfigReader } from "../../modelInstance/configReader";
+import { TwoDimConfigReader } from "../../modelInstance/configReader/twoDimConfigReader.ts/twoDimConfigReader";
+import { BarOptionsCanvas } from "../../../designer/designerConfig";
 export declare enum ScaleType {
     Key = 0,
     Value = 1
@@ -9,10 +10,12 @@ export declare enum ScaleType {
 export declare class ScaleModel {
     private readonly options;
     private readonly canvasModel;
-    constructor(options: MdtChartsTwoDimensionalOptions, canvasModel: CanvasModel);
-    getScaleKey(allowableKeys: string[]): ScaleKeyModel;
+    private readonly barCanvas;
+    constructor(options: MdtChartsTwoDimensionalOptions, canvasModel: CanvasModel, barCanvas: BarOptionsCanvas);
+    getScaleKey(domainValues: string[]): ScaleKeyModel;
     getScaleLinear(dataRows: MdtChartsDataRow[], configReader?: TwoDimConfigReader): ScaleValueModel;
     getScaleSecondaryLinear(dataRows: MdtChartsDataRow[], configReader?: TwoDimConfigReader): ScaleValueModel;
+    private getBandScaleSizeParams;
     private getChartsByTypes;
     private getScaleKeyType;
 }

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

@@ -6,21 +6,29 @@ export var ScaleType;
     ScaleType[ScaleType["Value"] = 1] = "Value";
 })(ScaleType || (ScaleType = {}));
 export class ScaleModel {
-    constructor(options, canvasModel) {
+    constructor(options, canvasModel, barCanvas) {
         this.options = options;
         this.canvasModel = canvasModel;
+        this.barCanvas = barCanvas;
     }
-    getScaleKey(allowableKeys) {
+    getScaleKey(domainValues) {
         const bandLikeCharts = this.getChartsByTypes(this.options.charts, ["bar", "dot"]);
-        return {
-            domain: allowableKeys,
+        const baseModel = {
+            domain: domainValues,
             range: {
                 start: 0,
                 end: getScaleKeyRangePeek(this.options.orientation, this.canvasModel)
-            },
-            type: this.getScaleKeyType(this.options.charts),
-            elementsAmount: getElementsAmountForScale(bandLikeCharts)
+            }
         };
+        const type = this.getScaleKeyType(this.options.charts);
+        if (type === "point") {
+            return Object.assign(Object.assign({}, baseModel), { type: "point" });
+        }
+        if (type === "band") {
+            const elementsInGroupAmount = getElementsAmountForScale(bandLikeCharts);
+            return Object.assign(Object.assign({}, baseModel), { type: "band", elementsAmount: elementsInGroupAmount, sizes: this.getBandScaleSizeParams(baseModel.domain, baseModel.range, elementsInGroupAmount) });
+        }
+        throw new Error("Unknown scale key type");
     }
     getScaleLinear(dataRows, configReader) {
         var _a;
@@ -46,6 +54,40 @@ export class ScaleModel {
             formatter: (_a = configReader === null || configReader === void 0 ? void 0 : configReader.getSecondaryAxisLabelFormatter()) !== null && _a !== void 0 ? _a : null
         };
     }
+    getBandScaleSizeParams(domainValues, range, elementsInGroupAmount) {
+        const paddings = {
+            outer: 0,
+            inner: 0
+        };
+        const getStepSize = () => (Math.abs(range.end - range.start) + paddings.inner - 2 * paddings.outer) / domainValues.length;
+        const getBandSize = () => getStepSize() - paddings.inner;
+        const initialBandSize = getBandSize();
+        if (this.barCanvas.groupMinDistance < initialBandSize) {
+            paddings.inner = this.barCanvas.groupMinDistance;
+            paddings.outer = this.barCanvas.groupMinDistance / 2;
+        }
+        //TODO: calculate without loop
+        while (getBandSize() >
+            this.barCanvas.maxBarWidth * elementsInGroupAmount +
+                this.barCanvas.barDistance * (elementsInGroupAmount - 1) &&
+            paddings.inner < this.barCanvas.groupMaxDistance) {
+            paddings.inner++;
+        }
+        paddings.outer = 1;
+        //TODO: calculate without loop
+        while (getStepSize() >
+            this.barCanvas.maxBarWidth * elementsInGroupAmount +
+                this.barCanvas.groupMaxDistance +
+                this.barCanvas.barDistance * (elementsInGroupAmount - 1)) {
+            paddings.outer += 1;
+        }
+        return {
+            paddingInner: paddings.inner,
+            paddingOuter: paddings.outer,
+            bandSize: initialBandSize,
+            recalculatedStepSize: getStepSize()
+        };
+    }
     getChartsByTypes(charts, types) {
         return charts.filter((chart) => types.includes(chart.type));
     }

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

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

package/lib/model/featuresModel/tooltipModel/tooltipContentModel.js

@@ -28,9 +28,9 @@ export class TwoDimTooltipContentGenerator {
                 valueField: initialRow.valueField
             };
         });
-        initialRows = ((_b = (_a = this.options.publicOptions) === null || _a === void 0 ? void 0 : _a.rows) === null || _b === void 0 ? void 0 : _b.filterPredicate)
-            ? initialRows.filter((row) => this.options.publicOptions.rows.filterPredicate(row))
-            : initialRows;
+        const filterPredicate = (_b = (_a = this.options.publicOptions) === null || _a === void 0 ? void 0 : _a.rows) === null || _b === void 0 ? void 0 : _b.filterPredicate;
+        if (filterPredicate)
+            initialRows = initialRows.filter((row) => filterPredicate(row));
         if ((_d = (_c = this.options.publicOptions) === null || _c === void 0 ? void 0 : _c.rows) === null || _d === void 0 ? void 0 : _d.sortCompareFn)
             initialRows.sort(this.options.publicOptions.rows.sortCompareFn);
         initialRows.forEach((initialRow) => {

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

@@ -1,9 +1,9 @@
-import { BlockMargin, Orient, ValueLabelAnchor, ValueLabelDominantBaseline } from "../../model";
+import { BlockMargin, Orient, TextAnchor, DominantBaseline } from "../../model";
 import { BoundingRect } from "../../../engine/features/valueLabelsCollision/valueLabelsCollision";
 import { MdtChartsDataRow, Size, ValueLabelsPositionMode, ValueLabelsPositionOptions, ValueLabelsRotationOptions } from "../../../config/config";
 interface ValueLabelAlignment {
-    dominantBaseline: ValueLabelDominantBaseline;
-    textAnchor: ValueLabelAnchor;
+    dominantBaseline: DominantBaseline;
+    textAnchor: TextAnchor;
 }
 export declare const VALUE_LABEL_OFFSET_ABS_SIZE_PX = 10;
 export declare const BORDER_OFFSET_SIZE_PX = 2;

package/lib/model/{EventEmitter.d.ts → helpers/eventEmitter.d.ts}

@@ -2,7 +2,7 @@ export declare class EventEmitter<E = Record<string, Record<string, any>>> {
     private events;
     subscribe<T extends keyof E>(code: T, listener: (args: E[T]) => void): () => void;
     unsubscribe<T extends keyof E>(code: T, listener: (args: E[T]) => void): void;
-    emit<T extends keyof E>(code: T, args?: E[T]): void;
+    emit<T extends keyof E>(code: T, args: E[T]): void;
     getSubscribeController(): {
         subscribe: <T extends keyof E>(code: T, listener: (args: E[T]) => void) => () => void;
         unsubscribe: <T_1 extends keyof E>(code: T_1, listener: (args: E[T_1]) => void) => void;

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

@@ -7,6 +7,6 @@ export declare class TwoDimensionalModelHelper {
     private static getGradientItems;
     private static calculateOpacityItem;
     private static getGradientItemColor;
-    static getValueLabels(valueLabels: MdtChartsTwoDimensionalValueLabels, canvasModel: CanvasModel, chartOrientation: ChartOrientation, styleModel: ValueLabelsStyleModel): TwoDimensionalValueLabels;
+    static getValueLabels(valueLabels: MdtChartsTwoDimensionalValueLabels | undefined, canvasModel: CanvasModel, chartOrientation: ChartOrientation, styleModel: ValueLabelsStyleModel): TwoDimensionalValueLabels;
     private static getChartBlockSidesOptions;
 }

package/lib/model/margin/marginModel.js

@@ -1,22 +1,22 @@
 import { TwoDimMarginModel } from "./twoDim/twoDimMarginModel";
-import { TwoDimConfigReader } from "../modelInstance/configReader";
+import { TwoDimConfigReader } from "../modelInstance/configReader/twoDimConfigReader.ts/twoDimConfigReader";
 export class MarginModel {
     constructor(designerConfig, config) {
         this.designerConfig = designerConfig;
         this.config = config;
-        //TODO: ensure
-        this.twoDimModel = new TwoDimMarginModel(this.designerConfig, new TwoDimConfigReader(this.config, this.designerConfig));
     }
     initMargin(otherComponents, modelInstance) {
         const canvasModel = modelInstance.canvasModel;
         canvasModel.initMargin(Object.assign({}, this.designerConfig.canvas.chartBlockMargin));
         this.recalcMarginByTitle(canvasModel);
         if (this.config.options.type === "2d") {
+            this.twoDimModel = new TwoDimMarginModel(this.designerConfig, new TwoDimConfigReader(this.config, this.designerConfig));
             this.twoDimModel.recalcMargin(otherComponents, modelInstance);
         }
     }
     recalcMarginByVerticalAxisLabel(modelInstance) {
-        this.twoDimModel.recalcMarginByVerticalAxisLabel(modelInstance);
+        var _a;
+        (_a = this.twoDimModel) === null || _a === void 0 ? void 0 : _a.recalcMarginByVerticalAxisLabel(modelInstance);
     }
     recalcMarginByTitle(canvasModel) {
         canvasModel.increaseMarginSide("top", canvasModel.titleCanvas.getAllNeededSpace());

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

@@ -1,6 +1,6 @@
 import { DesignerConfig } from "../../../designer/designerConfig";
 import { OtherCommonComponents } from "../../model";
-import { TwoDimConfigReader } from "../../modelInstance/configReader";
+import { TwoDimConfigReader } from "../../modelInstance/configReader/twoDimConfigReader.ts/twoDimConfigReader";
 import { ModelInstance } from "../../modelInstance/modelInstance";
 export declare const AXIS_HORIZONTAL_LABEL_PADDING = 12;
 export declare const AXIS_VERTICAL_LABEL_PADDING = 8;

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

@@ -35,6 +35,8 @@ export class TwoDimMarginModel {
             this.configReader.options.orientation === "vertical") {
             this.recalcVerticalMarginWithValueLabelsOn(canvasModel);
         }
+        const groupingSlices = this.configReader.grouping.getSlicesSizesByOrients(modelInstance.dataModel.repository.getRawRows());
+        groupingSlices.forEach((slice) => canvasModel.increaseMarginSide(slice.orient, slice.size));
     }
     recalcMarginByVerticalAxisLabel(modelInstance) {
         if (this.configReader.options.orientation === "vertical") {
@@ -55,13 +57,13 @@ export class TwoDimMarginModel {
             labelsTexts = modelInstance.dataModel.repository.getValuesByKeyField();
         }
         else {
-            const scaleModel = new ScaleModel(this.configReader.options, modelInstance.canvasModel).getScaleLinear(modelInstance.dataModel.repository.getRawRows(), this.configReader);
+            const scaleModel = new ScaleModel(this.configReader.options, modelInstance.canvasModel, this.designerConfig.canvas.chartOptions.bar).getScaleLinear(modelInstance.dataModel.repository.getRawRows(), this.configReader);
             labelsTexts = this.getValueAxisLabels(scaleModel).map((v) => this.configReader.getAxisLabelFormatter()(v).toString());
         }
         return AxisModel.getLabelSize(this.designerConfig.canvas.axisLabel.maxSize.main, labelsTexts);
     }
     getMaxLabelSizeSecondary(modelInstance) {
-        const scaleModel = new ScaleModel(this.configReader.options, modelInstance.canvasModel).getScaleSecondaryLinear(modelInstance.dataModel.repository.getRawRows(), this.configReader);
+        const scaleModel = new ScaleModel(this.configReader.options, modelInstance.canvasModel, this.designerConfig.canvas.chartOptions.bar).getScaleSecondaryLinear(modelInstance.dataModel.repository.getRawRows(), this.configReader);
         const labelsTexts = this.getValueAxisLabels(scaleModel).map((v) => this.configReader.getSecondaryAxisLabelFormatter()(v).toString());
         return AxisModel.getLabelSize(this.designerConfig.canvas.axisLabel.maxSize.main, labelsTexts);
     }
@@ -87,6 +89,7 @@ export class TwoDimMarginModel {
         }
     }
     recalcMarginBySecondaryAxisLabelSize(labelSize, canvasModel) {
+        var _a;
         const valueAxisOrient = AxisModel.getAxisOrient(AxisType.Value, this.configReader.options.orientation, this.configReader.options.axis.value.position);
         const secondaryOrientByMain = {
             bottom: "top",
@@ -99,7 +102,7 @@ export class TwoDimMarginModel {
             vertical: labelSize.width + AXIS_VERTICAL_LABEL_PADDING,
             horizontal: labelSize.height + AXIS_HORIZONTAL_LABEL_PADDING
         };
-        if (this.configReader.options.axis.valueSecondary.visibility) {
+        if ((_a = this.configReader.options.axis.valueSecondary) === null || _a === void 0 ? void 0 : _a.visibility) {
             canvasModel.increaseMarginSide(secondaryOrient, sizeMap[this.configReader.options.orientation]);
         }
     }

package/lib/model/model.d.ts

@@ -3,7 +3,7 @@ import { DataType, DonutOptionsCanvas, Formatter, StaticLegendBlockCanvas, Toolt
 import { BoundingRect } from "../engine/features/valueLabelsCollision/valueLabelsCollision";
 declare type AxisType = "key" | "value";
 export declare type Orient = "top" | "bottom" | "left" | "right";
-export declare type ScaleKeyType = "band" | "point";
+export declare type ScaleKeyType = (ScaleBandModel | ScalePointModel)["type"];
 export declare type ScaleValueType = "linear";
 export declare type LegendPosition = "off" | "top" | "bottom" | "left" | "right";
 export declare type EmbeddedLabelTypeModel = "none" | "key" | "value";
@@ -11,8 +11,8 @@ export declare type DataOptions = {
     [option: string]: any;
 };
 export declare type UnitsFromConfig = "%" | "px";
-export declare type ValueLabelAnchor = "start" | "middle" | "end";
-export declare type ValueLabelDominantBaseline = "hanging" | "middle" | "auto";
+export declare type TextAnchor = "start" | "middle" | "end";
+export declare type DominantBaseline = "hanging" | "middle" | "auto";
 export declare type GradientId = string;
 export declare type OptionsModel = TwoDimensionalOptionsModel | PolarOptionsModel;
 export interface Model<O = OptionsModel> {
@@ -80,6 +80,7 @@ export interface TwoDimensionalOptionsModel extends GraphicNotationOptionsModel
     orient: ChartOrientation;
     chartSettings: TwoDimChartElementsSettings;
     valueLabels: TwoDimensionalValueLabels;
+    grouping: TwoDimGroupingModel;
 }
 export interface PolarOptionsModel extends GraphicNotationOptionsModel {
     type: "polar";
@@ -126,12 +127,26 @@ export interface IScaleModel {
     value: ScaleValueModel;
     valueSecondary?: ScaleValueModel;
 }
-export interface ScaleKeyModel {
+export interface BaseScaleKeyModel {
     domain: any[];
     range: RangeModel;
-    type: ScaleKeyType;
+}
+export declare type ScaleKeyModel = ScaleBandModel | ScalePointModel;
+export interface ScaleBandModel extends BaseScaleKeyModel {
+    type: "band";
+    sizes: ScaleBandModelSizeParams;
+    /** @deprecated Use sizes instead */
     elementsAmount: number;
 }
+export interface ScaleBandModelSizeParams {
+    paddingOuter: number;
+    paddingInner: number;
+    bandSize: number;
+    recalculatedStepSize: number;
+}
+export interface ScalePointModel extends BaseScaleKeyModel {
+    type: "point";
+}
 export interface ScaleValueModel {
     domain: any[];
     range: RangeModel;
@@ -158,6 +173,9 @@ export interface AxisModelOptions {
     line: AxisLineModel;
     browserTooltip: AxisBrowserTooltipModel;
 }
+export interface DiscreteAxisModelOptions extends AxisModelOptions {
+    labels: DiscreteAxisLabelModel;
+}
 export interface AxisBrowserTooltipModel {
     format: (value: number | string) => string | number;
 }
@@ -180,6 +198,12 @@ export interface AxisLabelModel {
     linearTickStep: number;
     tickAmountSettings: TickAmountModel;
 }
+export interface DiscreteAxisLabelModel extends AxisLabelModel {
+    format: DiscreteAxisLabelFormatterModel;
+}
+export declare type DiscreteAxisLabelFormatterModel = (options: {
+    key: string;
+}) => string;
 interface TickAmountModel {
     policy: TickAmountPolicy;
 }
@@ -285,6 +309,25 @@ export declare type ValueLabelsChartBlockSide = {
 } | {
     mode: "none";
 };
+export interface TwoDimGroupingModel {
+    enabled: boolean;
+    items: TwoDimGroupingItemModel[];
+}
+export interface GroupingLabelCoordinate {
+    x: number;
+    y: number;
+}
+export declare type GroupingLabelKey = string | number;
+export interface TwoDimGroupingItemModel {
+    domain: GroupingLabelKey[];
+    orient: Orient;
+    textAnchor: TextAnchor;
+    dominantBaseline: DominantBaseline;
+    coordinate: {
+        handleX: (key: GroupingLabelKey) => number;
+        handleY: (key: GroupingLabelKey) => number;
+    };
+}
 export interface DonutChartSettings extends Omit<DonutOptionsCanvas, "aggregatorPad" | "thickness"> {
     aggregator: DonutAggregatorModel;
     thickness: DonutThicknessOptions;
@@ -377,7 +420,7 @@ interface DotChartShapeOptions {
     handleEndCoordinate: (calculatedBandItemSize: number) => number;
     width: number;
 }
-export interface TwoDimensionalChartModel extends ChartModel, TwoDimensionalLineLikeChartModel, TwoDimensionalBarLikeChartModel, TwoDimensionalAreaChartModel, DotChartModel, DotChartModel {
+export interface TwoDimensionalChartModel extends ChartModel, TwoDimensionalLineLikeChartModel, TwoDimensionalBarLikeChartModel, TwoDimensionalAreaChartModel, DotChartModel {
     type: TwoDimensionalChartType;
     data: TwoDimensionalChartDataModel;
     index: number;
@@ -410,9 +453,9 @@ export interface TwoDimChartValueLabelsOptions {
     showLabel: MarkerLikeElementVisibilityFn;
     handleX: (scaledValue: number) => number;
     handleY: (scaledValue: number) => number;
-    textAnchor: ValueLabelAnchor;
+    textAnchor: TextAnchor;
     forFields: MdtChartsFieldName[];
-    dominantBaseline: ValueLabelDominantBaseline;
+    dominantBaseline: DominantBaseline;
     setContent: ValueLabelsInnerContentSetter;
     handleScaledValue: (dataRow: MdtChartsDataRow, datumField: string) => number;
     rotation?: ValueLabelsRotationOptions;

package/lib/model/modelBuilder.js

@@ -5,7 +5,7 @@ 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 { TwoDimConfigReader } from "./modelInstance/configReader/twoDimConfigReader.ts/twoDimConfigReader";
 import { TitleConfigReader } from "./modelInstance/titleConfigReader";
 export var AxisType;
 (function (AxisType) {
@@ -52,6 +52,7 @@ function getOptions(config, designerConfig, modelInstance) {
     else if (config.options.type === "polar") {
         return PolarModel.getOptions(config.options, designerConfig, modelInstance);
     }
+    throw new Error("Unknown chart type");
 }
 function getDataSettings(dataScope, designerConfig) {
     return {

package/lib/model/modelInstance/canvasModel/legendCanvasModel.d.ts

@@ -1,7 +1,12 @@
 import { ILegendModel, LegendPosition } from "../../model";
 export declare class LegendCanvasModelInstance {
     private position;
+    private size;
+    private pad;
+    private sizeAndPadInited;
     getModel(): ILegendModel;
+    initSizeAndPad(size: number, pad: number): void;
     getPosition(): LegendPosition;
     setPosition(position: LegendPosition): void;
+    getAllNeededSpace(): number;
 }

package/lib/model/modelInstance/canvasModel/legendCanvasModel.js

@@ -1,13 +1,26 @@
 export class LegendCanvasModelInstance {
+    constructor() {
+        this.sizeAndPadInited = false;
+    }
     getModel() {
         return {
             position: this.position
         };
     }
+    initSizeAndPad(size, pad) {
+        this.size = size;
+        this.pad = pad;
+        this.sizeAndPadInited = true;
+    }
     getPosition() {
         return this.position;
     }
     setPosition(position) {
         this.position = position;
     }
+    getAllNeededSpace() {
+        if (!this.sizeAndPadInited)
+            throw new Error("LegendCanvasModel padding and size are not initialized");
+        return this.size + this.pad;
+    }
 }

package/lib/model/modelInstance/canvasModel/titleCanvas.d.ts

@@ -1,9 +1,9 @@
 import { TitleBlockModel } from "../../model";
-declare type TitleBlockCanvas = TitleBlockModel;
+import { TitleConfigReader } from "../titleConfigReader";
 export declare class TitleCanvasModel {
+    private inited;
     private model;
-    init(model: TitleBlockCanvas): void;
+    init(titleConfig: TitleConfigReader): void;
     getModel(): TitleBlockModel;
     getAllNeededSpace(): number;
 }
-export {};

package/lib/model/modelInstance/canvasModel/titleCanvas.js

@@ -1,11 +1,30 @@
 export class TitleCanvasModel {
-    init(model) {
-        this.model = model;
+    constructor() {
+        this.inited = false;
+    }
+    init(titleConfig) {
+        const defaultPads = titleConfig.getFontSize();
+        const pad = titleConfig.getTextContent() ? defaultPads : 0;
+        this.model = {
+            margin: {
+                bottom: 5,
+                left: 0,
+                right: 0,
+                top: 0
+            },
+            size: pad,
+            pad: 0
+        };
+        this.inited = true;
     }
     getModel() {
+        if (!this.inited)
+            throw new Error("TitleCanvasModel is not initialized");
         return this.model;
     }
     getAllNeededSpace() {
+        if (!this.inited)
+            throw new Error("TitleCanvasModel is not initialized");
         return this.model.pad + this.model.size + this.model.margin.top + this.model.margin.bottom;
     }
 }

package/lib/model/modelInstance/configReader/baseConfigReader.d.ts

@@ -0,0 +1,6 @@
+import { MdtChartsConfig, MdtChartsField } from "../../../config/config";
+import { DesignerConfig } from "../../../designer/designerConfig";
+export interface BaseConfigReader {
+    getValueFields(): MdtChartsField[];
+}
+export declare function getConfigReader(config: MdtChartsConfig, designerConfig: DesignerConfig): BaseConfigReader;

package/lib/model/modelInstance/configReader/baseConfigReader.js

@@ -0,0 +1,9 @@
+import { PolarConfigReader } from "./polarConfigReader/polarConfigReader";
+import { TwoDimConfigReader } from "./twoDimConfigReader.ts/twoDimConfigReader";
+export function getConfigReader(config, designerConfig) {
+    if (config.options.type === "2d")
+        return new TwoDimConfigReader(config, designerConfig);
+    if (config.options.type === "polar")
+        return new PolarConfigReader(config);
+    throw new Error(`Config reader for type "${config.options.type}" not exists`);
+}

package/lib/model/modelInstance/configReader/polarConfigReader/polarConfigReader.d.ts

@@ -0,0 +1,7 @@
+import { MdtChartsConfig, MdtChartsField } from "../../../../config/config";
+import { BaseConfigReader } from "../baseConfigReader";
+export declare class PolarConfigReader implements BaseConfigReader {
+    private options;
+    constructor(config: MdtChartsConfig);
+    getValueFields(): MdtChartsField[];
+}

package/lib/model/modelInstance/configReader/polarConfigReader/polarConfigReader.js

@@ -0,0 +1,8 @@
+export class PolarConfigReader {
+    constructor(config) {
+        this.options = config.options;
+    }
+    getValueFields() {
+        return [this.options.chart.data.valueField];
+    }
+}

package/lib/model/modelInstance/configReader/twoDimConfigReader.ts/groupingConfigReader/groupingConfigReader.d.ts

@@ -0,0 +1,29 @@
+import { ChartOrientation, DiscreteAxisOptions, MdtChartsDataRow, MdtChartsField, TwoDimGroupingOptions } from "../../../../../config/config";
+import { DominantBaseline, Orient, TextAnchor } from "../../../../model";
+export declare class GroupingConfigReader {
+    private readonly keyAxisOptions;
+    private readonly chartOrientation;
+    private readonly groupingOptions?;
+    private readonly maxLabelSize;
+    constructor(keyAxisOptions: DiscreteAxisOptions, chartOrientation: ChartOrientation, groupingOptions?: TwoDimGroupingOptions);
+    isEnabled(): boolean;
+    getSlicesByOrients(): {
+        orient: Orient;
+        amount: number;
+    }[];
+    getSlicesSizesByOrients(dataRows: MdtChartsDataRow[]): {
+        orient: Orient;
+        size: number;
+    }[];
+    getPreparedOptions(scopedDatasourceRows: MdtChartsDataRow[]): {
+        domain: string[];
+        orient: Orient;
+        sideIndex: number;
+        field: MdtChartsField;
+        textAnchor: TextAnchor;
+        dominantBaseline: DominantBaseline;
+    }[];
+    private getLabelValuesForItem;
+    private getLabelOrient;
+    private getLabelPosition;
+}