mdt-charts 1.21.2 → 1.23.0

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

@@ -1,23 +1,5 @@
 import { CLASSES } from "../../modelBuilder";
 export class LegendCanvasModel {
-    static getLegendItemWidth(text) {
-        const itemWrapper = document.createElement('div');
-        itemWrapper.style.opacity = '0';
-        const colorBlock = document.createElement('span');
-        const textBlock = document.createElement('span');
-        itemWrapper.style.display = 'inline-block';
-        itemWrapper.classList.add(CLASSES.legendItem);
-        colorBlock.classList.add(CLASSES.legendColor);
-        textBlock.classList.add(CLASSES.legendLabel);
-        textBlock.textContent = text;
-        itemWrapper.append(colorBlock, textBlock);
-        document.body.append(itemWrapper);
-        const sumWidth = itemWrapper.getBoundingClientRect().width
-            + parseFloat(window.getComputedStyle(itemWrapper, null).getPropertyValue('margin-left'))
-            + parseFloat(window.getComputedStyle(itemWrapper, null).getPropertyValue('margin-right'));
-        itemWrapper.remove();
-        return sumWidth;
-    }
     //TODO: find better solution
     static findElementsAmountByLegendSize(items, position, legendBlockWidth, legendBlockHeight) {
         const legendWrapper = this.getLegendWrapperEl(legendBlockWidth, position === "right" ? "column" : "row");

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

@@ -11,7 +11,7 @@ export class LegendModel {
                 },
                 bottom: {
                     size: 0,
-                    margin: { top: 10, bottom: 20, left: 0, right: 0 },
+                    margin: { top: 2, bottom: 0, left: 0, right: 0 },
                     pad: 0
                 },
                 right: {

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

@@ -1,10 +1,10 @@
-import { Legend } from "../../../config/config";
+import { MdtChartsTwoDimLegend } from "../../../config/config";
 import { LegendBlockModel } from "../../model";
 import { TwoDimConfigReader } from "../../modelInstance/configReader";
 import { ModelInstance } from "../../modelInstance/modelInstance";
 export declare class TwoDimLegendModel {
     private configReader;
     constructor(configReader: TwoDimConfigReader);
-    recalcMarginWith2DLegend(modelInstance: ModelInstance, legendBlockModel: LegendBlockModel, legendOptions: Legend): void;
+    recalcMarginWith2DLegend(modelInstance: ModelInstance, legendBlockModel: LegendBlockModel, legendOptions: MdtChartsTwoDimLegend): void;
     private getLegendModel;
 }

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

@@ -24,7 +24,9 @@ export class TwoDimLegendModel {
         }
     }
     getLegendModel(legendOptions) {
-        const position = legendOptions.show ? "top" : "off";
+        var _a;
+        const position = legendOptions.show
+            ? (_a = legendOptions.position) !== null && _a !== void 0 ? _a : "top" : "off";
         return {
             position
         };

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

@@ -7,7 +7,7 @@ export declare enum ScaleType {
     Value = 1
 }
 export declare class ScaleModel {
-    getScaleKey(allowableKeys: string[], orient: ChartOrientation, canvasModel: CanvasModel, charts: MdtChartsTwoDimensionalChart[], barCharts: MdtChartsTwoDimensionalChart[]): ScaleKeyModel;
+    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 getScaleKeyType;

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

@@ -6,7 +6,7 @@ export var ScaleType;
     ScaleType[ScaleType["Value"] = 1] = "Value";
 })(ScaleType || (ScaleType = {}));
 export class ScaleModel {
-    getScaleKey(allowableKeys, orient, canvasModel, charts, barCharts) {
+    getScaleKey(allowableKeys, orient, canvasModel, charts, bandLikeCharts) {
         return {
             domain: allowableKeys,
             range: {
@@ -14,7 +14,7 @@ export class ScaleModel {
                 end: getScaleKeyRangePeek(orient, canvasModel)
             },
             type: this.getScaleKeyType(charts),
-            elementsAmount: getElementsAmountForScale(barCharts)
+            elementsAmount: getElementsAmountForScale(bandLikeCharts)
         };
     }
     getScaleLinear(options, dataRows, canvasModel, configReader) {
@@ -42,8 +42,8 @@ export class ScaleModel {
         };
     }
     getScaleKeyType(charts) {
-        if (charts.findIndex((chart) => chart.type === 'bar') === -1)
-            return 'point';
-        return 'band';
+        if (charts.some((chart) => chart.type === 'bar' || chart.type === 'dot'))
+            return 'band';
+        return 'point';
     }
 }

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

@@ -2,4 +2,4 @@ import { ChartOrientation, MdtChartsTwoDimensionalChart } from "../../../config/
 import { CanvasSizesModel } from "../../modelInstance/canvasModel/canvasSizesModel/canvasSizeModel";
 export declare function getScaleKeyRangePeek(chartOrientation: ChartOrientation, canvasModel: CanvasSizesModel): number;
 export declare function getScaleValueRangePeek(chartOrientation: string, canvasModel: CanvasSizesModel): number;
-export declare function getElementsAmountForScale(barCharts: MdtChartsTwoDimensionalChart[]): number;
+export declare function getElementsAmountForScale(bandLikeCharts: MdtChartsTwoDimensionalChart[]): number;

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

@@ -8,15 +8,21 @@ export function getScaleValueRangePeek(chartOrientation, canvasModel) {
         return canvasModel.getChartBlockHeight();
     return canvasModel.getChartBlockWidth();
 }
-export function getElementsAmountForScale(barCharts) {
-    if (barCharts.length === 0)
+export function getElementsAmountForScale(bandLikeCharts) {
+    if (bandLikeCharts.length === 0)
         return 1;
-    let barsAmount = 0;
-    barCharts.forEach(chart => {
-        if (chart.isSegmented)
-            barsAmount += 1; // Если бар сегментированный, то все valueFields являются частями одного бара
-        else
-            barsAmount += chart.data.valueFields.length;
+    let barAmounts = {};
+    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;
+            else
+                barAmounts[chart.type] += chart.data.valueFields.length;
+        }
     });
-    return barsAmount;
+    return Math.max(...Object.values(barAmounts));
 }

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

@@ -1,4 +1,6 @@
 import { BlockMargin, Orient, ValueLabelAnchor, ValueLabelDominantBaseline } from "../../model";
+import { BoundingRect } from "../../../engine/features/valueLabelsCollision/valueLabelsCollision";
+import { Size } from "../../../config/config";
 interface ValueLabelAlignment {
     dominantBaseline: ValueLabelDominantBaseline;
     textAnchor: ValueLabelAnchor;
@@ -6,4 +8,8 @@ interface ValueLabelAlignment {
 export declare function getValueLabelY(scaledValue: number, keyAxisOrient: Orient, margin: BlockMargin): number;
 export declare function getValueLabelX(scaledValue: number, keyAxisOrient: Orient, margin: BlockMargin): number;
 export declare function calculateValueLabelAlignment(keyAxisOrient: Orient): ValueLabelAlignment;
+export declare function hasCollisionLeftSide(labelClientRect: BoundingRect, margin: BlockMargin): boolean;
+export declare function hasCollisionRightSide(labelClientRect: BoundingRect, blockSize: Size, margin: BlockMargin): boolean;
+export declare function shiftCoordinateXLeft(labelClientRect: BoundingRect): void;
+export declare function shiftCoordinateXRight(labelClientRect: BoundingRect): void;
 export {};

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

@@ -1,4 +1,5 @@
 const OFFSET_SIZE_PX = 10;
+const BORDER_OFFSET_SIZE_PX = 2;
 export function getValueLabelY(scaledValue, keyAxisOrient, margin) {
     switch (keyAxisOrient) {
         case 'bottom':
@@ -31,3 +32,15 @@ export function calculateValueLabelAlignment(keyAxisOrient) {
             return { dominantBaseline: "middle", textAnchor: "end" };
     }
 }
+export function hasCollisionLeftSide(labelClientRect, margin) {
+    return labelClientRect.x - labelClientRect.width / 2 <= margin.left;
+}
+export function hasCollisionRightSide(labelClientRect, blockSize, margin) {
+    return labelClientRect.x + labelClientRect.width / 2 >= blockSize.width - margin.right;
+}
+export function shiftCoordinateXLeft(labelClientRect) {
+    labelClientRect.x -= labelClientRect.width / 2 + BORDER_OFFSET_SIZE_PX;
+}
+export function shiftCoordinateXRight(labelClientRect) {
+    labelClientRect.x += +labelClientRect.width / 2 + BORDER_OFFSET_SIZE_PX;
+}

package/lib/model/model.d.ts

@@ -1,5 +1,6 @@
-import { ChartOrientation, MdtChartsColorField, IntervalChartType, PolarChartType, Size, TooltipOptions, TwoDimensionalChartType, AxisLabelPosition, ShowTickFn, MdtChartsDataRow, TwoDimensionalValueGroup, ValueLabelsCollision } from "../config/config";
+import { ChartOrientation, MdtChartsColorField, IntervalChartType, PolarChartType, Size, TooltipOptions, TwoDimensionalChartType, AxisLabelPosition, ShowTickFn, MdtChartsDataRow, TwoDimensionalValueGroup, ValueLabelsCollisionMode } 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";
 export declare type Orient = "top" | "bottom" | "left" | "right";
 export declare type ScaleKeyType = "band" | "point";
@@ -134,6 +135,10 @@ export interface AxisModelOptions {
     cssClass: string;
     ticks: AxisTicksModel;
     labels: AxisLabelModel;
+    line: AxisLineModel;
+}
+export interface AxisLineModel {
+    visible: boolean;
 }
 export interface TranslateModel {
     translateX: number;
@@ -155,11 +160,18 @@ export interface AdditionalElementsOptions {
 }
 export interface GridLineOptions {
     flag: GridLineFlag;
+    styles: GridLineStyles;
 }
 export interface GridLineFlag {
     key: boolean;
     value: boolean;
 }
+interface GridLineStyles {
+    dash: GridLineStylesDash;
+}
+interface GridLineStylesDash {
+    on: boolean;
+}
 export interface TwoDimChartElementsSettings {
     bar: BarChartSettings;
     lineLike: LineLikeChartSettings;
@@ -194,9 +206,41 @@ interface LineLikeChartCurveOptions {
 interface BarLikeChartHatchOptions {
     on: boolean;
 }
+export interface BarLikeChartBorderRadius {
+    grouped: BarBorderRadius;
+    segmented: SegmentedBarBorderRadius;
+}
+export interface BarBorderRadius {
+    topLeft: number;
+    topRight: number;
+    bottomLeft: number;
+    bottomRight: number;
+}
+interface SegmentedBarBorderRadius {
+    handle: (segmentIndex: number) => BarBorderRadius;
+}
 export interface TwoDimensionalValueLabels {
     collision: ValueLabelsCollision;
 }
+export interface ValueLabelsCollision {
+    otherValueLables: OtherValueLables;
+    chartBlock: ValueLabelsChartBlock;
+}
+export interface OtherValueLables {
+    mode: ValueLabelsCollisionMode;
+}
+export interface ValueLabelsChartBlock {
+    left: {
+        mode: "none" | "shift";
+        hasCollision: (labelClientRect: BoundingRect) => boolean;
+        shiftCoordinate: (labelClientRect: BoundingRect) => void;
+    };
+    right: {
+        mode: "none" | "shift";
+        hasCollision: (labelClientRect: BoundingRect) => boolean;
+        shiftCoordinate: (labelClientRect: BoundingRect) => void;
+    };
+}
 export interface DonutChartSettings extends Omit<DonutOptionsCanvas, "aggregatorPad" | "thickness"> {
     aggregator: DonutAggregatorModel;
     thickness: DonutThicknessOptions;
@@ -234,11 +278,13 @@ export interface ChartLegendModel {
     lineViewOptions: TwoDimensionalChartLegendLineModel;
 }
 export declare type LegendMarkerShape = "default" | "bar" | "line";
-export interface TwoDimensionalChartLegendBarModel extends TwoDimensionalBarLikeChartViewModel {
+export interface TwoDimensionalChartLegendBarModel {
+    hatch: BarLikeChartHatchOptions;
+    borderRadius: BarBorderRadius;
     width: number;
 }
 export interface TwoDimensionalChartLegendLineModel extends Omit<TwoDimensionalLineLikeChartViewModel, 'renderForKey'> {
-    width: number;
+    length: number;
 }
 interface TwoDimensionalLineLikeChartModel {
     lineLikeViewOptions: TwoDimensionalLineLikeChartViewModel;
@@ -246,14 +292,16 @@ interface TwoDimensionalLineLikeChartModel {
 }
 interface TwoDimensionalLineLikeChartViewModel {
     dashedStyles: LineLikeChartDashOptions;
+    strokeWidth: number;
     renderForKey: LineLikeChartRenderFn;
 }
 export declare type LineLikeChartRenderFn = (dataRow: MdtChartsDataRow, valueFieldName: string) => boolean;
 interface TwoDimensionalBarLikeChartModel {
     barViewOptions: TwoDimensionalBarLikeChartViewModel;
 }
-interface TwoDimensionalBarLikeChartViewModel {
+export interface TwoDimensionalBarLikeChartViewModel {
     hatch: BarLikeChartHatchOptions;
+    borderRadius: BarLikeChartBorderRadius;
 }
 interface TwoDimensionalAreaChartModel {
     areaViewOptions: AreaChartViewOptions;
@@ -272,14 +320,26 @@ export interface AreaViewBorderLine {
     on: boolean;
     colorStyle: ChartStyle;
 }
-export interface TwoDimensionalChartModel extends ChartModel, TwoDimensionalLineLikeChartModel, TwoDimensionalBarLikeChartModel, TwoDimensionalAreaChartModel {
+export interface DotChartModel {
+    dotViewOptions: DotChartViewModel;
+}
+export interface DotChartViewModel {
+    shape: DotChartShapeOptions;
+}
+interface DotChartShapeOptions {
+    type: "line";
+    handleStartCoordinate: (calculatedBandItemStartCoordinate: number) => number;
+    handleEndCoordinate: (calculatedBandItemSize: number) => number;
+    width: number;
+}
+export interface TwoDimensionalChartModel extends ChartModel, TwoDimensionalLineLikeChartModel, TwoDimensionalBarLikeChartModel, TwoDimensionalAreaChartModel, DotChartModel, DotChartModel {
     type: TwoDimensionalChartType;
     data: TwoDimensionalChartDataModel;
     index: number;
     embeddedLabels: EmbeddedLabelTypeModel;
     isSegmented: boolean;
     legend: ChartLegendModel;
-    valueLabels?: TwoDimChartValueLabelsOptions;
+    valueLabels: TwoDimChartValueLabelsOptions;
 }
 export interface IntervalChartModel extends Omit<ChartModel, "legend"> {
     type: IntervalChartType;

package/lib/model/modelBuilder.js

@@ -76,12 +76,10 @@ export function assembleModel(config, data, designerConfig) {
             options: null,
             dataSettings: null
         };
-    const dataRows = modelInstance.dataModel.repository.getRawRows();
-    const resolvedTitle = getResolvedTitle(config.options.title, dataRows);
     const otherComponents = OtherComponentsModel.getOtherComponentsModel({
         elementsOptions: designerConfig.elementsOptions,
         legendConfig: designerConfig.canvas.legendBlock,
-        title: resolvedTitle
+        title: getResolvedTitle(config.options.title, modelInstance.dataModel.repository.getRawRows())
     }, modelInstance);
     const marginModel = new MarginModel(designerConfig, config);
     marginModel.initMargin(otherComponents, modelInstance);

package/lib/model/modelInstance/configReader.js

@@ -55,18 +55,18 @@ export class TwoDimConfigReader {
         return !!this.options.axis.valueSecondary && this.options.charts.some(chart => chart.data.valueGroup === 'secondary');
     }
     getValueLabelFormatterForChart(chartIndex) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const chart = this.options.charts[chartIndex];
         const axis = this.options.axis;
-        if (chart.valueLabels.format)
+        if ((_a = chart.valueLabels) === null || _a === void 0 ? void 0 : _a.format)
             return chart.valueLabels.format;
         if (chart.data.valueGroup === "secondary") {
-            if ((_a = axis.valueSecondary.labels) === null || _a === void 0 ? void 0 : _a.format)
+            if ((_b = axis.valueSecondary.labels) === null || _b === void 0 ? void 0 : _b.format)
                 return axis.valueSecondary.labels.format;
-            else if ((_b = axis.value.labels) === null || _b === void 0 ? void 0 : _b.format)
+            else if ((_c = axis.value.labels) === null || _c === void 0 ? void 0 : _c.format)
                 return axis.value.labels.format;
         }
-        else if ((_c = axis.value.labels) === null || _c === void 0 ? void 0 : _c.format)
+        else if ((_d = axis.value.labels) === null || _d === void 0 ? void 0 : _d.format)
             return axis.value.labels.format;
         const valueFieldFormat = chart.data.valueFields[0].format;
         return (v) => this.designerConfig.dataFormat.formatters(v, { type: valueFieldFormat });

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

@@ -47,13 +47,21 @@ export class PolarModel {
         chartsModel.push({
             type: chart.type,
             data: Object.assign({}, chart.data),
-            tooltip: chart.tooltip,
+            tooltip: { show: true },
             cssClasses: ChartStyleModelService.getCssClasses(0),
             style: ChartStyleModelService.getChartStyle(dataLength, chartStyleConfig),
             legend: {
                 markerShape: "default",
-                barViewOptions: { hatch: { on: false }, width: 0 },
-                lineViewOptions: { dashedStyles: { on: false, dashSize: 0, gapSize: 0 }, width: 0 }
+                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;

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

@@ -1,8 +1,11 @@
-import { AreaChartViewOptions, ChartLegendModel, ChartStyle, GradientId, LineLikeChartDashOptions, LineLikeChartShapeOptions } from "../../model";
+import { AreaChartViewOptions, BarBorderRadius, ChartLegendModel, ChartStyle, GradientId, LineLikeChartDashOptions, LineLikeChartShapeOptions, Orient, TwoDimensionalBarLikeChartViewModel } from "../../model";
 import { ChartOrientation, MdtChartsLineLikeChartDashedStyles, MdtChartsTwoDimensionalChart, TwoDimensionalChartType } from "../../../config/config";
 import { MdtChartsLineLikeChartShape } from "../../../designer/designerConfig";
+export declare const LINE_CHART_DEFAULT_WIDTH = 2;
 export declare function parseShape(chartOrientation: ChartOrientation, configOptions?: MdtChartsLineLikeChartShape): LineLikeChartShapeOptions;
 export declare function parseDashStyles(configOptions?: MdtChartsLineLikeChartDashedStyles): LineLikeChartDashOptions;
+export declare function getBarViewOptions(chart: MdtChartsTwoDimensionalChart, keyAxisOrient: Orient): TwoDimensionalBarLikeChartViewModel;
+export declare function getSegmentedRadiusValues(segmentsLength: number, segmentIndex: number, keyAxisOrient: Orient, defaultRadius: number): BarBorderRadius;
 export declare function getLegendMarkerOptions(chart: MdtChartsTwoDimensionalChart): ChartLegendModel;
 export declare function getWidthOfLegendMarkerByType(chartType: TwoDimensionalChartType): number;
 export declare function getAreaViewOptions(chart: MdtChartsTwoDimensionalChart, chartIndex: number, style: ChartStyle): AreaChartViewOptions;

package/lib/model/notations/twoDimensional/styles.js

@@ -1,5 +1,7 @@
 import { LineCurveType } from "../../model";
 import { styledElementValues } from "../../modelBuilder";
+const BAR_CHART_BORDER_RADIUS_DEFAULT = 2;
+export const LINE_CHART_DEFAULT_WIDTH = 2;
 export function parseShape(chartOrientation, configOptions) {
     var _a;
     const curveType = (_a = configOptions === null || configOptions === void 0 ? void 0 : configOptions.curve) === null || _a === void 0 ? void 0 : _a.type;
@@ -27,17 +29,72 @@ export function parseDashStyles(configOptions) {
         gapSize: (_c = configOptions === null || configOptions === void 0 ? void 0 : configOptions.gapSize) !== null && _c !== void 0 ? _c : DEFAULT_GAP_SIZE_PX
     };
 }
+export function getBarViewOptions(chart, keyAxisOrient) {
+    var _a, _b, _c, _d, _e, _f;
+    const hatch = { on: (_c = (_b = (_a = chart.barStyles) === null || _a === void 0 ? void 0 : _a.hatch) === null || _b === void 0 ? void 0 : _b.on) !== null && _c !== void 0 ? _c : false };
+    const defaultRadius = (_f = (_e = (_d = chart.barStyles) === null || _d === void 0 ? void 0 : _d.borderRadius) === null || _e === void 0 ? void 0 : _e.value) !== null && _f !== void 0 ? _f : BAR_CHART_BORDER_RADIUS_DEFAULT;
+    const borderRadius = {
+        grouped: getRadiusValues(defaultRadius),
+        segmented: {
+            handle: (valueIndex) => getSegmentedRadiusValues(chart.data.valueFields.length, valueIndex, keyAxisOrient, defaultRadius),
+        }
+    };
+    return { hatch, borderRadius };
+}
+function getRadiusValues(defaultRadius) {
+    return {
+        topLeft: defaultRadius,
+        topRight: defaultRadius,
+        bottomLeft: defaultRadius,
+        bottomRight: defaultRadius
+    };
+}
+export function getSegmentedRadiusValues(segmentsLength, segmentIndex, keyAxisOrient, defaultRadius) {
+    const radiusConfigs = {
+        first: {
+            top: { topLeft: defaultRadius, topRight: defaultRadius, bottomLeft: 0, bottomRight: 0 },
+            bottom: { topLeft: 0, topRight: 0, bottomLeft: defaultRadius, bottomRight: defaultRadius },
+            left: { topLeft: defaultRadius, topRight: 0, bottomLeft: defaultRadius, bottomRight: 0 },
+            right: { topLeft: 0, topRight: defaultRadius, bottomLeft: 0, bottomRight: defaultRadius },
+        },
+        last: {
+            top: { topLeft: 0, topRight: 0, bottomLeft: defaultRadius, bottomRight: defaultRadius },
+            bottom: { topLeft: defaultRadius, topRight: defaultRadius, bottomLeft: 0, bottomRight: 0 },
+            left: { topLeft: 0, topRight: defaultRadius, bottomLeft: 0, bottomRight: defaultRadius },
+            right: { topLeft: defaultRadius, topRight: 0, bottomLeft: defaultRadius, bottomRight: 0 },
+        },
+        middle: { topLeft: 0, topRight: 0, bottomLeft: 0, bottomRight: 0 },
+        default: getRadiusValues(defaultRadius)
+    };
+    if (segmentsLength === 1)
+        return radiusConfigs.default;
+    else if (segmentIndex === 0)
+        return radiusConfigs.first[keyAxisOrient];
+    else if (segmentIndex === segmentsLength - 1)
+        return radiusConfigs.last[keyAxisOrient];
+    else
+        return radiusConfigs.middle;
+}
 export function getLegendMarkerOptions(chart) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     const shapeByType = {
         area: "default",
         bar: "bar",
-        line: "line"
+        line: "line",
+        dot: "default"
     };
     return {
         markerShape: shapeByType[chart.type],
-        barViewOptions: { hatch: { on: (_c = (_b = (_a = chart.barStyles) === null || _a === void 0 ? void 0 : _a.hatch) === null || _b === void 0 ? void 0 : _b.on) !== null && _c !== void 0 ? _c : false }, width: getWidthOfLegendMarkerByType("bar") },
-        lineViewOptions: { dashedStyles: parseDashStyles((_d = chart.lineStyles) === null || _d === void 0 ? void 0 : _d.dash), width: getWidthOfLegendMarkerByType("line") }
+        barViewOptions: {
+            hatch: { on: (_c = (_b = (_a = chart.barStyles) === null || _a === void 0 ? void 0 : _a.hatch) === null || _b === void 0 ? void 0 : _b.on) !== null && _c !== void 0 ? _c : false },
+            borderRadius: getRadiusValues((_f = (_e = (_d = chart.barStyles) === null || _d === void 0 ? void 0 : _d.borderRadius) === null || _e === void 0 ? void 0 : _e.value) !== null && _f !== void 0 ? _f : BAR_CHART_BORDER_RADIUS_DEFAULT),
+            width: getWidthOfLegendMarkerByType("bar")
+        },
+        lineViewOptions: {
+            dashedStyles: parseDashStyles((_g = chart.lineStyles) === null || _g === void 0 ? void 0 : _g.dash),
+            strokeWidth: (_j = (_h = chart.lineStyles) === null || _h === void 0 ? void 0 : _h.width) !== null && _j !== void 0 ? _j : LINE_CHART_DEFAULT_WIDTH,
+            length: getWidthOfLegendMarkerByType("line")
+        }
     };
 }
 export function getWidthOfLegendMarkerByType(chartType) {

package/lib/model/notations/twoDimensionalModel.d.ts

@@ -17,5 +17,6 @@ export declare class TwoDimensionalModel {
     private static findChartsWithEmbeddedKeyLabels;
     private static getEmbeddedLabelType;
     private static getAdditionalElements;
-    private static getChartsByType;
+    private static getChartsByTypes;
+    private static getValueLabels;
 }