mdt-charts 1.30.2 → 1.32.0

package/lib/model/featuresModel/tooltipModel/contentByNotations/tooltipContentInitialRowsProvider.d.ts

@@ -0,0 +1,13 @@
+import { MdtChartsDataRow } from "../../../../config/config";
+import { TooltipMarkerModel, ValueField } from "../../../model";
+export interface TooltipContentInitialRow {
+    marker: TooltipMarkerModel;
+    valueField: ValueField;
+}
+export interface TooltipContentInitialRowsProviderContext {
+    keyFieldValue: string;
+    currentDataRow: MdtChartsDataRow;
+}
+export interface TooltipContentInitialRowsProvider {
+    getInitialRows(context: TooltipContentInitialRowsProviderContext): TooltipContentInitialRow[];
+}

package/lib/model/featuresModel/tooltipModel/contentByNotations/tooltipContentInitialRowsProvider.js

@@ -0,0 +1 @@
+export {};

package/lib/model/featuresModel/tooltipModel/contentByNotations/twoDimInitialRowsProvider.d.ts

@@ -0,0 +1,10 @@
+import { TwoDimensionalChartModel } from "../../../model";
+import { TooltipContentInitialRow, TooltipContentInitialRowsProvider } from "./tooltipContentInitialRowsProvider";
+export interface TwoDimInitialRowsProviderOptions {
+    chartsInfo: Pick<TwoDimensionalChartModel, "data" | "style" | "legend">[];
+}
+export declare class TwoDimInitialRowsProvider implements TooltipContentInitialRowsProvider {
+    private readonly options;
+    constructor(options: TwoDimInitialRowsProviderOptions);
+    getInitialRows(): TooltipContentInitialRow[];
+}

package/lib/model/featuresModel/tooltipModel/contentByNotations/twoDimInitialRowsProvider.js

@@ -0,0 +1,17 @@
+export class TwoDimInitialRowsProvider {
+    constructor(options) {
+        this.options = options;
+    }
+    getInitialRows() {
+        const initialRows = [];
+        this.options.chartsInfo.forEach((chart) => {
+            chart.data.valueFields.forEach((valueField, valueFieldIndex) => {
+                initialRows.push({
+                    marker: Object.assign({ color: chart.style.elementColors[valueFieldIndex % chart.style.elementColors.length] }, chart.legend),
+                    valueField
+                });
+            });
+        });
+        return initialRows;
+    }
+}

package/lib/model/featuresModel/tooltipModel/tooltipCanvasModel.d.ts

@@ -0,0 +1,4 @@
+import { TooltipSettings } from "../../../designer/designerConfig";
+export declare class TooltipCanvasModel {
+    static getCanvasModel(options: TooltipSettings): TooltipSettings;
+}

package/lib/model/featuresModel/{tooltipModel.js → tooltipModel/tooltipCanvasModel.js}

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

package/lib/model/featuresModel/tooltipModel/tooltipContentModel.d.ts

@@ -0,0 +1,18 @@
+import { MdtChartsDataRow, TooltipOptions } from "../../../config/config";
+import { Formatter } from "../../../main";
+import { TooltipContent } from "../../model";
+import { TooltipContentInitialRowsProvider } from "./contentByNotations/tooltipContentInitialRowsProvider";
+export interface TooltipContentGeneratorOptions {
+    datasource: MdtChartsDataRow[];
+    initialRowsProvider: TooltipContentInitialRowsProvider;
+    publicOptions?: TooltipOptions;
+    keyFieldName: string;
+    valueGlobalFormatter: Formatter;
+}
+export declare class TwoDimTooltipContentGenerator {
+    private readonly options;
+    private readonly headWrapperCssClassName;
+    constructor(options: TooltipContentGeneratorOptions);
+    generateContent(keyFieldValue: string): TooltipContent;
+    private createRows;
+}

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

@@ -0,0 +1,87 @@
+export class TwoDimTooltipContentGenerator {
+    constructor(options) {
+        this.options = options;
+        this.headWrapperCssClassName = "tooltip-head";
+    }
+    generateContent(keyFieldValue) {
+        var _a;
+        const currentDataRow = this.options.datasource.find((r) => r[this.options.keyFieldName] === keyFieldValue);
+        if ((_a = this.options.publicOptions) === null || _a === void 0 ? void 0 : _a.html)
+            return {
+                type: "html",
+                htmlContent: this.options.publicOptions.html(currentDataRow)
+            };
+        return this.createRows(keyFieldValue, currentDataRow);
+    }
+    createRows(keyFieldValue, currentDataRow) {
+        var _a, _b, _c, _d, _e;
+        let contentRows = [];
+        let initialRows = this.options.initialRowsProvider
+            .getInitialRows({ keyFieldValue, currentDataRow })
+            .map((initialRow) => {
+            return {
+                marker: initialRow.marker,
+                textContent: {
+                    caption: initialRow.valueField.title,
+                    value: currentDataRow[initialRow.valueField.name]
+                },
+                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;
+        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) => {
+            var _a;
+            const formattedValueByDefault = this.options.valueGlobalFormatter(initialRow.textContent.value, {
+                type: initialRow.valueField.format
+            });
+            const formattedValue = ((_a = this.options.publicOptions) === null || _a === void 0 ? void 0 : _a.formatValue)
+                ? this.options.publicOptions.formatValue({
+                    rawValue: currentDataRow[initialRow.valueField.name],
+                    autoFormattedValue: formattedValueByDefault
+                })
+                : formattedValueByDefault;
+            contentRows.push({
+                marker: initialRow.marker,
+                textContent: {
+                    caption: initialRow.textContent.caption,
+                    value: formattedValue
+                }
+            });
+        });
+        if ((_e = this.options.publicOptions) === null || _e === void 0 ? void 0 : _e.aggregator) {
+            const contentResult = this.options.publicOptions.aggregator.content({ row: currentDataRow });
+            const aggregatorContent = Array.isArray(contentResult) ? contentResult : [contentResult];
+            const tooltipAggregatorItem = aggregatorContent.map((content) => {
+                const caption = content.type === "plainText" ? content.textContent : content.caption;
+                const value = content.type === "plainText" ? undefined : content.value;
+                return {
+                    textContent: {
+                        caption,
+                        value
+                    }
+                };
+            });
+            if (this.options.publicOptions.aggregator.position === "underValues")
+                contentRows = contentRows.concat(tooltipAggregatorItem);
+            else
+                contentRows = tooltipAggregatorItem.concat(contentRows);
+        }
+        const headerRow = {
+            textContent: {
+                caption: keyFieldValue
+            },
+            wrapper: {
+                cssClassName: this.headWrapperCssClassName
+            }
+        };
+        contentRows.unshift(headerRow);
+        return {
+            type: "rows",
+            rows: contentRows
+        };
+    }
+}

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

@@ -1,21 +1,22 @@
 import { BlockMargin, Orient, ValueLabelAnchor, ValueLabelDominantBaseline } from "../../model";
 import { BoundingRect } from "../../../engine/features/valueLabelsCollision/valueLabelsCollision";
-import { Size, ValueLabelsPositionMode, ValueLabelsRotationOptions } from "../../../config/config";
+import { MdtChartsDataRow, Size, ValueLabelsPositionMode, ValueLabelsPositionOptions, ValueLabelsRotationOptions } from "../../../config/config";
 interface ValueLabelAlignment {
     dominantBaseline: ValueLabelDominantBaseline;
     textAnchor: ValueLabelAnchor;
 }
-export declare const OFFSET_SIZE_PX = 10;
+export declare const VALUE_LABEL_OFFSET_ABS_SIZE_PX = 10;
 export declare const BORDER_OFFSET_SIZE_PX = 2;
 export declare class ValueLabelCoordinateCalculator {
     private readonly keyAxisOrient;
     private readonly margin;
     private readonly offsetSizePx;
-    constructor(positionMode: ValueLabelsPositionMode | undefined, keyAxisOrient: Orient, margin: BlockMargin);
+    constructor(positionOptions: ValueLabelsPositionOptions | undefined, keyAxisOrient: Orient, margin: BlockMargin);
     getValueLabelY(scaledValue: number): number;
     getValueLabelX(scaledValue: number): number;
 }
 export declare function calculateValueLabelAlignment(keyAxisOrient: Orient, positionMode?: ValueLabelsPositionMode, rotation?: ValueLabelsRotationOptions): ValueLabelAlignment;
+export declare function handleScaledValue(dataRow: MdtChartsDataRow, datumField: string, isSegmented: boolean, positionMode?: ValueLabelsPositionMode): number;
 export declare function hasCollisionLeftSide(labelClientRect: BoundingRect, margin: BlockMargin): boolean;
 export declare function hasCollisionRightSide(labelClientRect: BoundingRect, blockSize: Size, margin: BlockMargin): boolean;
 export declare function hasCollisionTopSide(labelClientRect: BoundingRect, margin: BlockMargin): boolean;

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

@@ -1,10 +1,19 @@
-export const OFFSET_SIZE_PX = 10;
+export const VALUE_LABEL_OFFSET_ABS_SIZE_PX = 10;
 export const BORDER_OFFSET_SIZE_PX = 2;
 export class ValueLabelCoordinateCalculator {
-    constructor(positionMode, keyAxisOrient, margin) {
+    constructor(positionOptions, keyAxisOrient, margin) {
         this.keyAxisOrient = keyAxisOrient;
         this.margin = margin;
-        this.offsetSizePx = positionMode === "center" ? 0 : OFFSET_SIZE_PX;
+        let offsetAbsSize = VALUE_LABEL_OFFSET_ABS_SIZE_PX;
+        if (((positionOptions === null || positionOptions === void 0 ? void 0 : positionOptions.mode) === "beforeHead" || (positionOptions === null || positionOptions === void 0 ? void 0 : positionOptions.mode) === "afterHead") &&
+            (positionOptions === null || positionOptions === void 0 ? void 0 : positionOptions.offsetSize) != null)
+            offsetAbsSize = positionOptions === null || positionOptions === void 0 ? void 0 : positionOptions.offsetSize;
+        if (!(positionOptions === null || positionOptions === void 0 ? void 0 : positionOptions.mode) || positionOptions.mode === "afterHead")
+            this.offsetSizePx = offsetAbsSize;
+        else if (positionOptions.mode === "beforeHead")
+            this.offsetSizePx = -offsetAbsSize;
+        else
+            this.offsetSizePx = 0;
     }
     getValueLabelY(scaledValue) {
         switch (this.keyAxisOrient) {
@@ -28,7 +37,9 @@ export class ValueLabelCoordinateCalculator {
     }
 }
 export function calculateValueLabelAlignment(keyAxisOrient, positionMode, rotation) {
-    if ((positionMode !== null && positionMode !== void 0 ? positionMode : "after") === "after" && !(rotation === null || rotation === void 0 ? void 0 : rotation.angle)) {
+    if (rotation === null || rotation === void 0 ? void 0 : rotation.angle)
+        return { dominantBaseline: "middle", textAnchor: "middle" };
+    if (!positionMode || positionMode === "afterHead") {
         switch (keyAxisOrient) {
             case "top":
                 return { dominantBaseline: "hanging", textAnchor: "middle" };
@@ -40,9 +51,30 @@ export function calculateValueLabelAlignment(keyAxisOrient, positionMode, rotati
                 return { dominantBaseline: "middle", textAnchor: "end" };
         }
     }
-    else {
-        return { dominantBaseline: "middle", textAnchor: "middle" };
+    else if (positionMode === "beforeHead") {
+        switch (keyAxisOrient) {
+            case "top":
+                return { dominantBaseline: "auto", textAnchor: "middle" };
+            case "bottom":
+                return { dominantBaseline: "hanging", textAnchor: "middle" };
+            case "left":
+                return { dominantBaseline: "middle", textAnchor: "end" };
+            case "right":
+                return { dominantBaseline: "middle", textAnchor: "start" };
+        }
+    }
+    return { dominantBaseline: "middle", textAnchor: "middle" };
+}
+export function handleScaledValue(dataRow, datumField, isSegmented, positionMode) {
+    if (!positionMode || positionMode === "afterHead" || positionMode === "beforeHead")
+        return dataRow[datumField];
+    if (positionMode === "center") {
+        if (isSegmented)
+            return dataRow[datumField] - (dataRow[datumField] - dataRow["0"]) / 2;
+        else
+            return dataRow[datumField] / 2;
     }
+    throw new Error("Invalid position mode");
 }
 export function hasCollisionLeftSide(labelClientRect, margin) {
     return labelClientRect.x - labelClientRect.width / 2 <= margin.left;

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

@@ -1,9 +1,9 @@
-import { AxisModel, LABEL_ELEMENT_HEIGHT_PX } from "../../featuresModel/axisModel";
+import { AxisModel, LABEL_ELEMENT_HEIGHT_PX } from "../../featuresModel/axis/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 { VALUE_LABEL_OFFSET_ABS_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;
@@ -110,7 +110,7 @@ export class TwoDimMarginModel {
             top: "bottom",
             bottom: "top"
         };
-        canvasModel.increaseMarginSide(axisMarginMapping[keyAxisOrient], valueLabelFontSize + OFFSET_SIZE_PX);
+        canvasModel.increaseMarginSide(axisMarginMapping[keyAxisOrient], valueLabelFontSize + VALUE_LABEL_OFFSET_ABS_SIZE_PX);
     }
     getValueAxisLabels(scaleModel) {
         const scale = Scale.getScaleValue(scaleModel);

package/lib/model/model.d.ts

@@ -1,4 +1,4 @@
-import { ChartOrientation, MdtChartsColorField, PolarChartType, Size, TooltipOptions, TwoDimensionalChartType, AxisLabelPosition, ShowTickFn, MdtChartsDataRow, TwoDimensionalValueGroup, ValueLabelsCollisionMode, ValueLabelsRotationOptions, ValueLabelsHandleElement } from "../config/config";
+import { ChartOrientation, MdtChartsColorField, PolarChartType, Size, TwoDimensionalChartType, AxisLabelPosition, ShowTickFn, MdtChartsDataRow, TwoDimensionalValueGroup, ValueLabelsCollisionMode, ValueLabelsRotationOptions, ValueLabelsHandleElement, MdtChartsFieldName } from "../config/config";
 import { DataType, DonutOptionsCanvas, Formatter, StaticLegendBlockCanvas, TooltipSettings, Transitions } from "../designer/designerConfig";
 import { BoundingRect } from "../engine/features/valueLabelsCollision/valueLabelsCollision";
 declare type AxisType = "key" | "value";
@@ -36,8 +36,32 @@ export interface BlockMargin {
     left: number;
     right: number;
 }
+export interface TooltipBasicModel {
+    getContent: (keyFieldValue: string) => TooltipContent;
+}
+export declare type TooltipMarkerModel = ChartLegendMarkerModel & {
+    color: string;
+};
+export declare type TooltipContent = {
+    type: "html";
+    htmlContent: string;
+} | TooltipContentWithRows;
+export interface TooltipContentWithRows {
+    type: "rows";
+    rows: TooltipContentRow[];
+}
+export interface TooltipContentRow {
+    marker?: TooltipMarkerModel;
+    textContent: {
+        caption: string;
+        value?: string | number;
+    };
+    wrapper?: {
+        cssClassName?: string;
+    };
+}
 interface BasicOptionsModel {
-    tooltip: TooltipOptions;
+    tooltip: TooltipBasicModel;
 }
 interface GraphicNotationOptionsModel extends BasicOptionsModel {
     legend: ILegendModel;
@@ -281,23 +305,23 @@ export interface DonutThicknessOptions {
     unit: DonutThicknessUnit;
 }
 interface ChartModel {
-    tooltip: TooltipModel;
     cssClasses: string[];
     style: ChartStyle;
 }
-interface TooltipModel {
-    show: boolean;
-}
 export interface ChartStyle {
     elementColors: string[];
     opacity: number;
 }
-export interface ChartLegendModel {
-    markerShape: LegendMarkerShape;
+export declare type ChartLegendMarkerModel = {
+    markerShape: "circle";
+} | {
+    markerShape: "bar";
     barViewOptions: TwoDimensionalChartLegendBarModel;
+} | {
+    markerShape: "line";
     lineViewOptions: TwoDimensionalChartLegendLineModel;
-}
-export declare type LegendMarkerShape = "default" | "bar" | "line";
+};
+export declare type LegendMarkerShape = ChartLegendMarkerModel["markerShape"];
 export interface TwoDimensionalChartLegendBarModel {
     hatch: BarLikeChartHatchOptions;
     borderRadius: BarBorderRadius;
@@ -359,13 +383,13 @@ export interface TwoDimensionalChartModel extends ChartModel, TwoDimensionalLine
     index: number;
     embeddedLabels: EmbeddedLabelTypeModel;
     isSegmented: boolean;
-    legend: ChartLegendModel;
+    legend: ChartLegendMarkerModel;
     valueLabels: TwoDimChartValueLabelsOptions;
 }
 export interface PolarChartModel extends ChartModel {
     type: PolarChartType;
     data: PolarChartDataModel;
-    legend: ChartLegendModel;
+    legend: ChartLegendMarkerModel;
 }
 export interface TwoDimensionalChartDataModel {
     valueFields: ValueField[];
@@ -374,13 +398,21 @@ export interface TwoDimensionalChartDataModel {
 export interface ValueField extends Field {
     title: string;
 }
+export interface ValueLabelsInnerContentSetterOptions {
+    dataRow: MdtChartsDataRow;
+    fieldName: MdtChartsFieldName;
+}
+export declare type ValueLabelsInnerContentSetter = (options: ValueLabelsInnerContentSetterOptions) => {
+    textContent: string | number;
+};
 export interface TwoDimChartValueLabelsOptions {
     show: boolean;
     handleX: (scaledValue: number) => number;
     handleY: (scaledValue: number) => number;
     textAnchor: ValueLabelAnchor;
+    forFields: MdtChartsFieldName[];
     dominantBaseline: ValueLabelDominantBaseline;
-    format: ValueLabelsFormatter;
+    setContent: ValueLabelsInnerContentSetter;
     handleScaledValue: (dataRow: MdtChartsDataRow, datumField: string) => number;
     rotation?: ValueLabelsRotationOptions;
     handleElement?: ValueLabelsHandleElement;

package/lib/model/modelInstance/configReader.js

@@ -73,7 +73,7 @@ export class TwoDimConfigReader {
         return this.options.charts.some((chart) => { var _a; return (_a = chart.valueLabels) === null || _a === void 0 ? void 0 : _a.on; });
     }
     areValueLabelsNeedIncreaseMargin() {
-        return !this.options.charts.every((chart) => { var _a, _b; return ((_b = (_a = chart.valueLabels) === null || _a === void 0 ? void 0 : _a.position) === null || _b === void 0 ? void 0 : _b.mode) === "center"; });
+        return this.options.charts.some((chart) => { var _a, _b, _c, _d; return !((_b = (_a = chart.valueLabels) === null || _a === void 0 ? void 0 : _a.position) === null || _b === void 0 ? void 0 : _b.mode) || ((_d = (_c = chart.valueLabels) === null || _c === void 0 ? void 0 : _c.position) === null || _d === void 0 ? void 0 : _d.mode) === "afterHead"; });
     }
     getValueLabelsStyleModel() {
         var _a, _b, _c, _d, _e, _f, _g, _h;

package/lib/model/notations/polar/modelConstants/polarLegendMarker.d.ts

@@ -0,0 +1,2 @@
+import { ChartLegendMarkerModel } from "../../../model";
+export declare const POLAR_LEGEND_MARKER: ChartLegendMarkerModel;

package/lib/model/notations/polar/modelConstants/polarLegendMarker.js

@@ -0,0 +1,3 @@
+export const POLAR_LEGEND_MARKER = {
+    markerShape: "circle"
+};

package/lib/model/notations/polar/polarModel.js

@@ -2,10 +2,14 @@ import { ChartStyleModelService } from "../../chartStyleModel/chartStyleModel";
 import { DonutModel } from "./donut/donutModel";
 import { TitleConfigReader } from "../../modelInstance/titleConfigReader";
 import { createRecordOverflowModel } from "../../featuresModel/recordOverflowModel/recordOverflowModel";
+import { POLAR_LEGEND_MARKER } from "./modelConstants/polarLegendMarker";
+import { TwoDimTooltipContentGenerator } from "../../featuresModel/tooltipModel/tooltipContentModel";
+import { PolarInitialRowsProvider } from "../../featuresModel/tooltipModel/contentByNotations/polarInitialRowsProvider";
 export const MIN_DONUT_BLOCK_SIZE = 120;
 export class PolarModel {
     static getOptions(options, designerConfig, modelInstance) {
         const titleConfig = TitleConfigReader.create(options.title, modelInstance);
+        const chart = this.getChartsModel(options.chart, modelInstance.dataModel.repository.getScopedRows().length, designerConfig.chartStyle);
         return {
             type: options.type,
             selectable: !!options.selectable,
@@ -14,9 +18,25 @@ export class PolarModel {
                 fontSize: titleConfig.getFontSize()
             },
             data: Object.assign({}, options.data),
-            charts: this.getChartsModel(options.chart, modelInstance.dataModel.repository.getScopedRows().length, designerConfig.chartStyle),
+            charts: [chart],
             legend: modelInstance.canvasModel.legendCanvas.getModel(),
-            tooltip: options.tooltip,
+            tooltip: {
+                getContent: (keyFieldValue) => {
+                    const generator = new TwoDimTooltipContentGenerator({
+                        datasource: modelInstance.dataModel.repository.getRawRows(),
+                        keyFieldName: options.data.keyField.name,
+                        publicOptions: options.tooltip,
+                        initialRowsProvider: new PolarInitialRowsProvider({
+                            datasource: modelInstance.dataModel.repository.getRawRows(),
+                            valueField: options.chart.data.valueField,
+                            keyFieldName: options.data.keyField.name,
+                            chartColors: chart.style.elementColors
+                        }),
+                        valueGlobalFormatter: designerConfig.dataFormat.formatters
+                    });
+                    return generator.generateContent(keyFieldValue);
+                }
+            },
             chartCanvas: this.getDonutSettings(designerConfig.canvas.chartOptions.donut, options.chart, modelInstance.dataModel.repository.getRawRows()),
             defs: { gradients: [] },
             recordOverflowAlert: createRecordOverflowModel(modelInstance.dataModel.getScope().hidedRecordsAmount, {
@@ -52,28 +72,13 @@ export class PolarModel {
         return this.donutModel.getSettings(settings, chartOptions, dataRows);
     }
     static getChartsModel(chart, dataLength, chartStyleConfig) {
-        const chartsModel = [];
-        chartsModel.push({
+        return {
             type: chart.type,
             data: Object.assign({}, chart.data),
-            tooltip: { show: true },
             cssClasses: ChartStyleModelService.getCssClasses(0),
             style: ChartStyleModelService.getChartStyle(dataLength, chartStyleConfig),
-            legend: {
-                markerShape: "default",
-                barViewOptions: {
-                    hatch: { on: false },
-                    borderRadius: { topLeft: 0, topRight: 0, bottomLeft: 0, bottomRight: 0 },
-                    width: 0
-                },
-                lineViewOptions: {
-                    dashedStyles: { on: false, dashSize: 0, gapSize: 0 },
-                    strokeWidth: 0,
-                    length: 0
-                }
-            }
-        });
-        return chartsModel;
+            legend: POLAR_LEGEND_MARKER
+        };
     }
 }
 PolarModel.donutModel = new DonutModel();

package/lib/model/notations/twoDimensional/styles.d.ts

@@ -1,4 +1,4 @@
-import { AreaChartViewOptions, BarBorderRadius, ChartLegendModel, ChartStyle, GradientId, LineLikeChartDashOptions, LineLikeChartShapeOptions, Orient, TwoDimensionalBarLikeChartViewModel, TwoDimensionalChartLegendLineModel } from "../../model";
+import { AreaChartViewOptions, BarBorderRadius, ChartLegendMarkerModel, ChartStyle, GradientId, LineLikeChartDashOptions, LineLikeChartShapeOptions, Orient, TwoDimensionalBarLikeChartViewModel, TwoDimensionalChartLegendLineModel } from "../../model";
 import { ChartOrientation, MdtChartsLineLikeChartDashedStyles, MdtChartsTwoDimensionalChart, TwoDimensionalChartType } from "../../../config/config";
 import { MdtChartsLineLikeChartShape } from "../../../designer/designerConfig";
 export declare const LINE_CHART_DEFAULT_WIDTH = 2;
@@ -7,7 +7,7 @@ export declare function parseDashStyles(configOptions?: MdtChartsLineLikeChartDa
 export declare function getBarViewOptions(chart: MdtChartsTwoDimensionalChart, keyAxisOrient: Orient, barIndexes: number[]): TwoDimensionalBarLikeChartViewModel;
 export declare function calculateBarIndexes(allCharts: Pick<MdtChartsTwoDimensionalChart, "isSegmented" | "data" | "type">[], currentChart: Pick<MdtChartsTwoDimensionalChart, "isSegmented" | "data" | "type">, currentChartIndex: number): number[];
 export declare function getSegmentedRadiusValues(segmentsLength: number, segmentIndex: number, keyAxisOrient: Orient, defaultRadius: number): BarBorderRadius;
-export declare function getLegendMarkerOptions(chart: MdtChartsTwoDimensionalChart): ChartLegendModel;
+export declare function getLegendMarkerOptions(chart: MdtChartsTwoDimensionalChart): ChartLegendMarkerModel;
 export declare function getLineViewOptions(chart: MdtChartsTwoDimensionalChart): TwoDimensionalChartLegendLineModel;
 export declare function getWidthOfLegendMarkerByType(chartType: TwoDimensionalChartType): number;
 export declare function getAreaViewOptions(chart: MdtChartsTwoDimensionalChart, chartIndex: number, style: ChartStyle, chartBlockId: number): AreaChartViewOptions;