mdt-charts 1.27.1 → 1.27.2

package/lib/engine/features/gridLine/gridLine.js

@@ -2,11 +2,10 @@ import { GridLineHelper } from "./gidLineHelper";
 export class GridLine {
     static render(block, options, axes, blockSize, margin, scales) {
         if (options.flag.value) {
-            const lineLength = GridLineHelper.getGridLineLength('value', axes.key, axes.value, blockSize, margin);
+            const lineLength = GridLineHelper.getGridLineLength("value", axes.key, axes.value, blockSize, margin);
             const lineAttributes = GridLineHelper.getLineAttributes(axes.value, lineLength);
-            this.renderLine(block, axes.value, lineAttributes, options)
-                .style('display', (d, i, group) => {
-                return d === 0 ? 'none' : 'block';
+            this.renderLine(block, axes.value, lineAttributes, options).style("display", (d, i, group) => {
+                return d === 0 ? "none" : "block";
             });
         }
         if (options.flag.key) {
@@ -22,28 +21,20 @@ export class GridLine {
         const gridLine = block
             .getSvg()
             .selectAll(`.${axis.cssClass}`)
-            .selectAll('g.tick')
-            .append('line')
-            .attr('class', this.gridLineClass)
-            .attr('x1', lineAttributes.x1)
-            .attr('y1', lineAttributes.y1)
-            .attr('x2', lineAttributes.x2)
-            .attr('y2', lineAttributes.y2);
+            .selectAll("g.tick")
+            .append("line")
+            .attr("class", this.gridLineClass)
+            .attr("x1", lineAttributes.x1)
+            .attr("y1", lineAttributes.y1)
+            .attr("x2", lineAttributes.x2)
+            .attr("y2", lineAttributes.y2);
         if (options.styles.dash.on)
-            gridLine.style('stroke-dasharray', 3);
+            gridLine.style("stroke-dasharray", 3);
         return gridLine;
     }
     static clear(block, keyAxisClass, valueAxisClass) {
-        block.getSvg()
-            .selectAll(`.${keyAxisClass} `)
-            .selectAll('g.tick')
-            .selectAll(`.${this.gridLineClass}`)
-            .remove();
-        block.getSvg()
-            .selectAll(`.${valueAxisClass}`)
-            .selectAll('g.tick')
-            .selectAll(`.${this.gridLineClass}`)
-            .remove();
+        block.getSvg().selectAll(`.${keyAxisClass} `).selectAll("g.tick").selectAll(`.${this.gridLineClass}`).remove();
+        block.getSvg().selectAll(`.${valueAxisClass}`).selectAll("g.tick").selectAll(`.${this.gridLineClass}`).remove();
     }
 }
-GridLine.gridLineClass = 'grid-line';
+GridLine.gridLineClass = "grid-line";

package/lib/engine/features/legend/legend.js

@@ -13,13 +13,13 @@ export class Legend {
         return new Legend();
     }
     render(block, data, options, model) {
-        if (options.legend.position !== 'off') {
+        if (options.legend.position !== "off") {
             const legendObject = this.renderObject(block, options.legend.position, model.otherComponents.legendBlock, model.blockCanvas.size);
             this.setContent(block, data, options, legendObject, model.otherComponents.legendBlock);
         }
     }
     update(block, data, model) {
-        if (model.options.legend.position !== 'off') {
+        if (model.options.legend.position !== "off") {
             const legendObject = this.getObject(block);
             const legendCoordinate = LegendHelper.getLegendCoordinateByPosition(model.options.legend.position, model.otherComponents.legendBlock, model.blockCanvas.size);
             this.fillCoordinate(legendObject, legendCoordinate);
@@ -32,8 +32,7 @@ export class Legend {
             return;
         const legendObject = this.getObject(block);
         const colors = LegendHelper.getMarksColor(options);
-        const itemWrappers = legendObject
-            .selectAll(`.${Legend.itemClass}`);
+        const itemWrappers = legendObject.selectAll(`.${Legend.itemClass}`);
         const markerCreator = this.markerCreator;
         itemWrappers.each(function (d, i) {
             const selection = select(this);
@@ -44,8 +43,8 @@ export class Legend {
         return block
             .getSvg()
             .selectAll(`.${this.itemClass}`)
-            .filter(d => {
-            const index = keys.findIndex(k => k === d.textContent);
+            .filter((d) => {
+            const index = keys.findIndex((k) => k === d.textContent);
             return condition === SelectionCondition.Include ? index !== -1 : index === -1;
         });
     }
@@ -54,7 +53,7 @@ export class Legend {
         const colors = LegendHelper.getMarksColor(options, data[options.data.dataSource]);
         const renderingOptions = LegendHelper.getContentRenderingOptions(options.type, options.legend.position, legendBlockModel);
         const itemBlocks = this.renderContent(legendObject, items, colors, renderingOptions);
-        if (options.type === 'polar') {
+        if (options.type === "polar") {
             LegendEventsManager.setListeners(block, options.data.keyField.name, itemBlocks, options.selectable);
         }
         else {
@@ -62,58 +61,50 @@ export class Legend {
         }
     }
     renderObject(block, legendPosition, legendBlockModel, blockSize) {
-        const legendObject = block.getSvg()
-            .append('foreignObject')
-            .attr('class', Legend.objectClass);
+        const legendObject = block.getSvg().append("foreignObject").attr("class", Legend.objectClass);
         const legendCoordinate = LegendHelper.getLegendCoordinateByPosition(legendPosition, legendBlockModel, blockSize);
         this.fillCoordinate(legendObject, legendCoordinate);
         return legendObject;
     }
     renderContent(foreignObject, items, colorPalette, options) {
-        const wrapper = foreignObject.append('xhtml:div');
+        const wrapper = foreignObject.append("xhtml:div");
         wrapper.classed(options.wrapperClasses.join(" "), true);
-        const itemWrappers = wrapper
-            .selectAll(`.${Legend.itemClass}`)
-            .data(items)
-            .enter()
-            .append('div');
+        const itemWrappers = wrapper.selectAll(`.${Legend.itemClass}`).data(items).enter().append("div");
         itemWrappers.classed(options.itemsOptions.wrapperClasses.join(" "), true);
         const markerCreator = this.markerCreator;
-        itemWrappers
-            .each(function (d, i) {
+        itemWrappers.each(function (d, i) {
             const selection = select(this);
             const markers = markerCreator.create(selection, Object.assign(Object.assign({}, d), { color: colorPalette[i % colorPalette.length] }));
             markers.classed(options.itemsOptions.markerClass, true);
         });
         itemWrappers
-            .append('span')
-            .attr('class', options.itemsOptions.labelClass)
-            .text(d => d.textContent);
+            .append("span")
+            .attr("class", options.itemsOptions.labelClass)
+            .text((d) => d.textContent);
         if (options.shouldCropLabels)
             LegendDomHelper.decreaseRowLabels(foreignObject, itemWrappers, options.blockModel.static);
         return itemWrappers;
     }
     getObject(block) {
-        return block.getSvg()
-            .select(`foreignObject.${Legend.objectClass}`);
+        return block.getSvg().select(`foreignObject.${Legend.objectClass}`);
     }
     removeContent(legendObject) {
         legendObject.select(`.${Legend.legendBlockClass}`).remove();
     }
     fillCoordinate(legendBlock, coordinate) {
         legendBlock
-            .attr('x', coordinate.x)
-            .attr('y', coordinate.y)
-            .attr('width', coordinate.width)
-            .attr('height', coordinate.height);
+            .attr("x", coordinate.x)
+            .attr("y", coordinate.y)
+            .attr("width", coordinate.width)
+            .attr("height", coordinate.height);
     }
 }
-Legend.objectClass = 'legend-object';
-Legend.labelClass = 'legend-label';
-Legend.label2DClass = 'legend-2d-label';
-Legend.labelPolarClass = 'legend-polar-label';
-Legend.labelIntervalClass = 'legend-interval-label';
-Legend.itemClass = 'legend-item';
-Legend.markerClass = 'legend-marker';
-Legend.markerCircle = 'legend-circle';
-Legend.legendBlockClass = 'legend-block';
+Legend.objectClass = "legend-object";
+Legend.labelClass = "legend-label";
+Legend.label2DClass = "legend-2d-label";
+Legend.labelPolarClass = "legend-polar-label";
+Legend.labelIntervalClass = "legend-interval-label";
+Legend.itemClass = "legend-item";
+Legend.markerClass = "legend-marker";
+Legend.markerCircle = "legend-circle";
+Legend.legendBlockClass = "legend-block";

package/lib/engine/features/legend/legendDomHelper.js

@@ -5,17 +5,24 @@ import { LegendHelper } from "./legendHelper";
 import { getNewLegendItemWidths } from "./legendWidthCalculator";
 export class LegendDomHelper {
     static setItemsTitles(items) {
-        items.attr('title', d => d.textContent);
+        items.attr("title", (d) => d.textContent);
     }
     static decreaseRowLabels(legendBlock, items, staticLegend) {
         let itemsRightMargins = this.getItemsRightMargins(items);
         const itemConfig = [];
         items.nodes().forEach((node, i) => {
-            itemConfig.push({ width: node.getBoundingClientRect().width, marginLeft: 0, marginRight: itemsRightMargins[i] });
+            itemConfig.push({
+                width: node.getBoundingClientRect().width,
+                marginLeft: 0,
+                marginRight: itemsRightMargins[i]
+            });
         });
         const newWidths = getNewLegendItemWidths({
             items: itemConfig,
-            wrapper: { maxRowsAmount: staticLegend.maxLinesAmount, width: legendBlock.node().getBoundingClientRect().width }
+            wrapper: {
+                maxRowsAmount: staticLegend.maxLinesAmount,
+                width: legendBlock.node().getBoundingClientRect().width
+            }
         });
         items.nodes().forEach((node, i) => {
             node.style.width = `${newWidths[i]}px`;
@@ -27,23 +34,23 @@ export class LegendDomHelper {
         let itemsLeftMargins = this.getItemsRightMargins(items);
         let itemsWidth = this.getItemsWidth(items);
         let sumOfItemsWidth = LegendHelper.getSumOfItemsWidths(itemsWidth, itemsLeftMargins);
-        const maxItemWidth = LegendHelper.getMaxItemWidth(legendBlock.attr('width'), itemsLeftMargins, 'row');
+        const maxItemWidth = LegendHelper.getMaxItemWidth(legendBlock.attr("width"), itemsLeftMargins, "row");
         let index = 0;
         let loopFlag = true; // if at least one label has no text, loop ends
         while (sumOfItemsWidth > maxWidth && loopFlag) {
-            items.nodes().forEach(node => {
+            items.nodes().forEach((node) => {
                 const textBlock = node.querySelector(`.${Legend.labelClass}`);
                 if (node.getBoundingClientRect().width > maxItemWidth && textBlock.textContent) {
                     let labelText = index > 0
                         ? textBlock.textContent.substr(0, textBlock.textContent.length - 3)
                         : textBlock.textContent;
                     labelText = labelText.substr(0, labelText.length - 1);
-                    textBlock.textContent = labelText + '...';
+                    textBlock.textContent = labelText + "...";
                     itemsLeftMargins = this.getItemsRightMargins(items);
                     itemsWidth = this.getItemsWidth(items);
                     sumOfItemsWidth = LegendHelper.getSumOfItemsWidths(itemsWidth, itemsLeftMargins);
                     if (labelText.length === 0) {
-                        textBlock.textContent = '';
+                        textBlock.textContent = "";
                         loopFlag = false;
                     }
                 }
@@ -52,9 +59,11 @@ export class LegendDomHelper {
         }
     }
     static getItemsRightMargins(items) {
-        return items.nodes().map(node => Helper.getPXValueFromString(DomHelper.getCssPropertyValue(node, 'margin-right')));
+        return items
+            .nodes()
+            .map((node) => Helper.getPXValueFromString(DomHelper.getCssPropertyValue(node, "margin-right")));
     }
     static getItemsWidth(items) {
-        return items.nodes().map(node => node.getBoundingClientRect().width);
+        return items.nodes().map((node) => node.getBoundingClientRect().width);
     }
 }

package/lib/engine/features/legend/legendEventsManager.js

@@ -14,9 +14,10 @@ export class LegendEventsManager {
     }
     static setHoverListeners(block, keyFieldName, legendItems) {
         const arcItems = Donut.getAllArcGroups(block);
-        legendItems.on('mousemove', function (e, keyValue) {
-            arcItems.filter((row) => row.data[keyFieldName] === keyValue.textContent)
-                .dispatch('mousemove', {
+        legendItems.on("mousemove", function (e, keyValue) {
+            arcItems
+                .filter((row) => row.data[keyFieldName] === keyValue.textContent)
+                .dispatch("mousemove", {
                 bubbles: false,
                 cancelable: true,
                 detail: {
@@ -25,23 +26,27 @@ export class LegendEventsManager {
                 }
             });
         });
-        legendItems.on('mouseover', function (e, keyValue) {
-            arcItems.filter((row) => row.data[keyFieldName] === keyValue.textContent)
-                .dispatch('mouseover');
+        legendItems.on("mouseover", function (e, keyValue) {
+            arcItems.filter((row) => row.data[keyFieldName] === keyValue.textContent).dispatch("mouseover");
             ElementHighlighter.toggleActivityStyle(select(this), true);
         });
-        legendItems.on('mouseleave', function (e, keyValue) {
-            arcItems.filter((row) => row.data[keyFieldName] === keyValue.textContent)
-                .dispatch('mouseleave');
-            if (!block.filterEventManager.isSelected(keyValue.textContent) && block.filterEventManager.getSelectedKeys().length > 0)
+        legendItems.on("mouseleave", function (e, keyValue) {
+            arcItems.filter((row) => row.data[keyFieldName] === keyValue.textContent).dispatch("mouseleave");
+            if (!block.filterEventManager.isSelected(keyValue.textContent) &&
+                block.filterEventManager.getSelectedKeys().length > 0)
                 ElementHighlighter.toggleActivityStyle(select(this), false);
         });
     }
     static setClickListeners(block, keyFieldName, legendItems) {
         const arcItems = Donut.getAllArcGroups(block);
-        legendItems.on('click', (e, keyValue) => {
-            arcItems.filter((row) => row.data[keyFieldName] === keyValue.textContent)
-                .dispatch('click', { bubbles: false, cancelable: true, detail: { multySelect: e.ctrlKey || e.metaKey } });
+        legendItems.on("click", (e, keyValue) => {
+            arcItems
+                .filter((row) => row.data[keyFieldName] === keyValue.textContent)
+                .dispatch("click", {
+                bubbles: false,
+                cancelable: true,
+                detail: { multySelect: e.ctrlKey || e.metaKey }
+            });
         });
     }
 }

package/lib/engine/features/legend/legendHelper.js

@@ -1,12 +1,12 @@
-import { Helper } from '../../helpers/helper';
+import { Helper } from "../../helpers/helper";
 import { Legend } from "./legend";
 import { LegendHelperService } from "./legendHelperService";
 export class LegendHelper {
     static getLegendItemsContent(options, data) {
-        if (options.type === '2d') {
+        if (options.type === "2d") {
             let texts = [];
-            options.charts.forEach(chart => {
-                texts = texts.concat(chart.data.valueFields.map(field => (Object.assign(Object.assign({}, chart.legend), { textContent: field.title }))));
+            options.charts.forEach((chart) => {
+                texts = texts.concat(chart.data.valueFields.map((field) => (Object.assign(Object.assign({}, chart.legend), { textContent: field.title }))));
             });
             return texts;
         }
@@ -15,21 +15,21 @@ export class LegendHelper {
         }
     }
     static getMarksColor(options, dataRows) {
-        if (options.type === '2d') {
+        if (options.type === "2d") {
             let colors = [];
-            options.charts.forEach(chart => {
+            options.charts.forEach((chart) => {
                 colors = colors.concat(chart.style.elementColors);
             });
             return colors;
         }
-        else if (options.type === 'polar') {
+        else if (options.type === "polar") {
             if (!options.charts[0].data.colorField)
-                return options.charts.map(chart => chart.style.elementColors)[0];
-            return dataRows.map(row => row[options.charts[0].data.colorField]);
+                return options.charts.map((chart) => chart.style.elementColors)[0];
+            return dataRows.map((row) => row[options.charts[0].data.colorField]);
         }
     }
     static getMaxItemWidth(legendBlockWidth, marginsLeft, itemsDirection) {
-        if (itemsDirection === 'row') {
+        if (itemsDirection === "row") {
             const sumOfMargins = Helper.getSumOfNumeric(marginsLeft);
             return (parseFloat(legendBlockWidth) - sumOfMargins) / marginsLeft.length;
         }
@@ -48,23 +48,23 @@ export class LegendHelper {
             width: 0,
             height: 0
         };
-        if (legendPosition === 'left' || legendPosition === 'right') {
+        if (legendPosition === "left" || legendPosition === "right") {
             coordinate.y = legendModel.margin.top + legendModel.pad;
             coordinate.width = legendModel.size;
             coordinate.height = blockSize.height - legendModel.margin.top - legendModel.margin.bottom;
         }
-        else if (legendPosition === 'bottom' || legendPosition === 'top') {
+        else if (legendPosition === "bottom" || legendPosition === "top") {
             coordinate.x = legendModel.margin.left;
             coordinate.width = blockSize.width - legendModel.margin.left - legendModel.margin.right;
             coordinate.height = legendModel.size;
         }
-        if (legendPosition === 'left')
+        if (legendPosition === "left")
             coordinate.x = legendModel.margin.left;
-        else if (legendPosition === 'right')
+        else if (legendPosition === "right")
             coordinate.x = blockSize.width - legendModel.size - legendModel.margin.right;
-        else if (legendPosition === 'top')
+        else if (legendPosition === "top")
             coordinate.y = legendModel.margin.top + legendModel.pad;
-        else if (legendPosition === 'bottom')
+        else if (legendPosition === "bottom")
             coordinate.y = blockSize.height - legendModel.size - legendModel.margin.bottom;
         return coordinate;
     }
@@ -89,9 +89,9 @@ export class LegendHelper {
     }
     static getLegendClassByChartNotation(chartNotation) {
         const legendClasses = {
-            '2d': Legend.label2DClass,
-            'polar': Legend.labelPolarClass,
-            'interval': Legend.labelIntervalClass
+            "2d": Legend.label2DClass,
+            polar: Legend.labelPolarClass,
+            interval: Legend.labelIntervalClass
         };
         return `${Legend.labelClass} ${legendClasses[chartNotation]}`;
     }

package/lib/engine/features/legend/legendHelperService.js

@@ -10,18 +10,18 @@ export class LegendHelperService {
     }
     getLegendLabelClassByPosition(legendPosition, chartNotation, initialLabelClass) {
         if (this.doesLegendInTopBy2d(legendPosition, chartNotation))
-            return `${initialLabelClass} ${initialLabelClass + '-nowrap'}`;
+            return `${initialLabelClass} ${initialLabelClass + "-nowrap"}`;
         return initialLabelClass;
     }
     getItemClasses(itemsDirection) {
-        return itemsDirection === 'column' ? 'legend-item-row' : 'legend-item-inline';
+        return itemsDirection === "column" ? "legend-item-row" : "legend-item-inline";
     }
     getLegendItemsDirection(legendPosition) {
-        if (legendPosition === 'right' || legendPosition === 'left')
-            return 'column';
+        if (legendPosition === "right" || legendPosition === "left")
+            return "column";
         return "row";
     }
     doesLegendInTopBy2d(legendPosition, chartNotation) {
-        return (legendPosition === 'top' || legendPosition === 'bottom') && chartNotation === "2d";
+        return (legendPosition === "top" || legendPosition === "bottom") && chartNotation === "2d";
     }
 }

package/lib/engine/features/legend/legendMarkerCreator.js

@@ -25,17 +25,18 @@ class DefaultMarkerCreator {
         this.cssClass = cssClass;
     }
     renderMarker(selection, color) {
-        return selection.append('span').style('background-color', color).classed(this.cssClass, true);
+        return selection.append("span").style("background-color", color).classed(this.cssClass, true);
     }
     updateColors(selection, color) {
-        selection.select(`.${this.cssClass}`).style('background-color', color);
+        selection.select(`.${this.cssClass}`).style("background-color", color);
     }
 }
 class SvgMarkerCreator {
     renderSvg(selection) {
-        return selection.append('svg')
+        return selection
+            .append("svg")
             .style("display", "inline-block")
-            .style("height", '8px')
+            .style("height", "8px")
             .classed(Legend.markerClass, true);
     }
 }
@@ -47,20 +48,20 @@ class BarMarkerCreator extends SvgMarkerCreator {
     renderMarker(selection, color) {
         const svg = this.renderSvg(selection).style("width", this.options.width);
         const bars = svg
-            .append('rect')
-            .attr('x', 0)
-            .attr('y', 0)
-            .attr('height', this.options.width)
-            .attr('width', this.options.width)
-            .style('fill', color)
-            .style('clip-path', getClipPathValue(this.options.borderRadius));
+            .append("rect")
+            .attr("x", 0)
+            .attr("y", 0)
+            .attr("height", this.options.width)
+            .attr("width", this.options.width)
+            .style("fill", color)
+            .style("clip-path", getClipPathValue(this.options.borderRadius));
         if (this.options.hatch.on) {
-            bars.style('mask', HatchPatternDef.getMaskValue());
+            bars.style("mask", HatchPatternDef.getMaskValue());
         }
         return bars;
     }
     updateColors(selection, color) {
-        selection.select('svg rect').style('fill', color);
+        selection.select("svg rect").style("fill", color);
     }
 }
 class LineMarkerCreator extends SvgMarkerCreator {
@@ -71,21 +72,21 @@ class LineMarkerCreator extends SvgMarkerCreator {
     renderMarker(selection, color) {
         const svg = this.renderSvg(selection).style("width", this.options.length);
         const line = svg
-            .append('line')
-            .style('stroke', 'red')
+            .append("line")
+            .style("stroke", "red")
             .classed("line", true)
-            .attr('x1', 0)
-            .attr('x2', this.options.length)
-            .attr('y1', 5)
-            .attr('y2', 5)
-            .style('stroke', color)
-            .style('stroke-width', this.options.strokeWidth);
+            .attr("x1", 0)
+            .attr("x2", this.options.length)
+            .attr("y1", 5)
+            .attr("y2", 5)
+            .style("stroke", color)
+            .style("stroke-width", this.options.strokeWidth);
         if (this.options.dashedStyles.on) {
             applyLineDash(line, this.options.dashedStyles.dashSize, this.options.dashedStyles.gapSize);
         }
         return line;
     }
     updateColors(selection, color) {
-        selection.select('svg line').style('stroke', color);
+        selection.select("svg line").style("stroke", color);
     }
 }

package/lib/engine/features/legend/legendWidthCalculator.js

@@ -1,6 +1,6 @@
 export function getNewLegendItemWidths(config) {
     const wrapper = new LegendWrapper(config.wrapper);
-    const collection = new LegendItemCollection(config.items.map(i => new LegendItem(i)));
+    const collection = new LegendItemCollection(config.items.map((i) => new LegendItem(i)));
     return getNewWidths(collection, wrapper);
 }
 function getNewWidths(collection, wrapper) {
@@ -13,9 +13,7 @@ function getNewWidths(collection, wrapper) {
     let avgExtra = extra / biggerThanAvg.length;
     biggerThanAvg.forEach((item, index) => {
         const avgDiff = item.getCurrentWidth() - avgWidth;
-        const decreaseBy = index === biggerThanAvg.length - 1
-            ? extra
-            : (avgDiff < avgExtra ? avgDiff : avgExtra);
+        const decreaseBy = index === biggerThanAvg.length - 1 ? extra : avgDiff < avgExtra ? avgDiff : avgExtra;
         item.decreaseBy(decreaseBy);
         extra -= decreaseBy;
         avgExtra = extra / (biggerThanAvg.length - index - 1);
@@ -101,7 +99,7 @@ class LegendItemCollection {
         return this.items.reduce((acc, item) => acc + item.getCurrentTotalWidth(), 0);
     }
     getActualWidths() {
-        return this.items.map(item => item.getCurrentWidth());
+        return this.items.map((item) => item.getCurrentWidth());
     }
     getTotalMarginSizes() {
         return this.items.reduce((acc, item) => acc + item.getTotalMarginSize(), 0);
@@ -111,7 +109,7 @@ class LegendItemCollection {
     }
     getItemsWithWidthBiggerThan(thanWidth) {
         return this.items
-            .filter(item => item.getCurrentWidth() > thanWidth)
+            .filter((item) => item.getCurrentWidth() > thanWidth)
             .sort((a, b) => a.getCurrentWidth() - b.getCurrentWidth());
     }
     getFirstItem() {
@@ -130,7 +128,7 @@ class LegendItemCollection {
         this.items.push(...items);
     }
     resetItemsToOriginalWidth() {
-        this.items.forEach(item => item.resetWidthToOriginal());
+        this.items.forEach((item) => item.resetWidthToOriginal());
         return this;
     }
 }

package/lib/engine/features/markDots/markDot.d.ts

@@ -1,5 +1,5 @@
-import { Selection, BaseType } from 'd3-selection';
-import { MdtChartsDataRow } from '../../../config/config';
+import { Selection, BaseType } from "d3-selection";
+import { MdtChartsDataRow } from "../../../config/config";
 import { BlockMargin, MarkersOptions, Orient, TwoDimensionalChartModel } from "../../../model/model";
 import { Block } from "../../block/block";
 import { Scales } from "../scale/scale";