mdt-charts 1.27.1 → 1.27.2

package/lib/engine/features/markDots/markDot.js

@@ -1,26 +1,28 @@
-import { select } from 'd3-selection';
-import { transition } from 'd3-transition';
-import { DomHelper } from '../../helpers/domHelper';
-import { Helper } from '../../helpers/helper';
-import { NamesHelper } from '../../helpers/namesHelper';
+import { select } from "d3-selection";
+import { transition } from "d3-transition";
+import { DomHelper } from "../../helpers/domHelper";
+import { Helper } from "../../helpers/helper";
+import { NamesHelper } from "../../helpers/namesHelper";
 import { MarkDotHelper } from "./markDotsHelper";
 select.prototype.transition = transition;
 export class MarkDot {
     static render(block, data, keyAxisOrient, scales, margin, keyFieldName, vfIndex, valueFieldName, chart) {
-        const dotsWrapper = block.svg.getChartGroup(chart.index)
+        const dotsWrapper = block.svg
+            .getChartGroup(chart.index)
             .selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-index-${vfIndex}`)
-            .data(data.map(row => (Object.assign(Object.assign({}, row), { $mdtChartsMetadata: { valueFieldName } }))))
+            .data(data.map((row) => (Object.assign(Object.assign({}, row), { $mdtChartsMetadata: { valueFieldName } }))))
             .enter();
         const attrs = MarkDotHelper.getDotAttrs(keyAxisOrient, scales, margin, keyFieldName, valueFieldName, chart.isSegmented);
-        const dots = dotsWrapper.append('circle');
+        const dots = dotsWrapper.append("circle");
         this.setAttrs(block, dots, attrs, chart.markersOptions.styles);
         this.setClassesAndStyle(dots, chart.cssClasses, vfIndex, chart.style.elementColors);
         MarkDot.tryMakeMarkDotVisible(dots, chart.markersOptions, false);
     }
     static update(block, newData, keyAxisOrient, scales, margin, keyFieldName, vfIndex, valueFieldName, chart) {
-        const dots = block.svg.getChartGroup(chart.index)
+        const dots = block.svg
+            .getChartGroup(chart.index)
             .selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${vfIndex}`)
-            .data(newData.map(row => (Object.assign(Object.assign({}, row), { $mdtChartsMetadata: { valueFieldName } }))));
+            .data(newData.map((row) => (Object.assign(Object.assign({}, row), { $mdtChartsMetadata: { valueFieldName } }))));
         dots.exit().remove();
         dots.each(function (datum) {
             if (chart.markersOptions.show({ row: datum, valueFieldName })) {
@@ -28,33 +30,33 @@ export class MarkDot {
             }
         });
         const attrs = MarkDotHelper.getDotAttrs(keyAxisOrient, scales, margin, keyFieldName, valueFieldName, chart.isSegmented);
-        const newDots = dots
-            .enter()
-            .append('circle');
+        const newDots = dots.enter().append("circle");
         this.setAttrs(block, newDots, attrs, chart.markersOptions.styles);
         this.setClassesAndStyle(newDots, chart.cssClasses, vfIndex, chart.style.elementColors);
         MarkDot.tryMakeMarkDotVisible(newDots, chart.markersOptions, false);
-        const animationName = 'data-updating';
-        dots
-            .interrupt(animationName)
+        const animationName = "data-updating";
+        dots.interrupt(animationName)
             .transition(animationName)
             .duration(block.transitionManager.durations.chartUpdate)
-            .attr('cx', d => attrs.cx(d))
-            .attr('cy', d => attrs.cy(d));
+            .attr("cx", (d) => attrs.cx(d))
+            .attr("cy", (d) => attrs.cy(d));
     }
     static updateColors(block, chart, valueFieldIndex) {
-        const dots = block.svg.getChartGroup(chart.index)
+        const dots = block.svg
+            .getChartGroup(chart.index)
             .selectAll(`.${this.markerDotClass}${Helper.getCssClassesLine(chart.cssClasses)}.chart-element-${valueFieldIndex}`);
-        DomHelper.setChartElementColor(dots, chart.style.elementColors, valueFieldIndex, 'stroke');
+        DomHelper.setChartElementColor(dots, chart.style.elementColors, valueFieldIndex, "stroke");
     }
     static getMarkDotForChart(block, chartCssClasses) {
-        return block.getSvg()
-            .selectAll(`.${MarkDot.markerDotClass}${Helper.getCssClassesLine(chartCssClasses)}`);
+        return block.getSvg().selectAll(`.${MarkDot.markerDotClass}${Helper.getCssClassesLine(chartCssClasses)}`);
     }
     static tryMakeMarkDotVisible(elems, markersOptions, turnOnIfCan) {
         elems.each(function (datum) {
             var _a;
-            if (!markersOptions.show({ row: datum, valueFieldName: (_a = datum.$mdtChartsMetadata) === null || _a === void 0 ? void 0 : _a.valueFieldName }))
+            if (!markersOptions.show({
+                row: datum,
+                valueFieldName: (_a = datum.$mdtChartsMetadata) === null || _a === void 0 ? void 0 : _a.valueFieldName
+            }))
                 MarkDot.toggleMarkDotVisible(select(this), turnOnIfCan);
         });
     }
@@ -63,18 +65,17 @@ export class MarkDot {
     }
     static setClassesAndStyle(dots, cssClasses, vfIndex, elementColors) {
         DomHelper.setCssClasses(dots, Helper.getCssClassesWithElementIndex(cssClasses, vfIndex));
-        DomHelper.setChartElementColor(dots, elementColors, vfIndex, 'stroke');
+        DomHelper.setChartElementColor(dots, elementColors, vfIndex, "stroke");
     }
     static setAttrs(block, dots, attrs, styles) {
-        dots
-            .attr('class', this.markerDotClass)
-            .attr('cx', d => attrs.cx(d))
-            .attr('cy', d => attrs.cy(d))
-            .attr('r', styles.normal.size.radius)
-            .style('stroke-width', styles.normal.size.borderSize)
-            .style('fill', 'white')
-            .style('clip-path', `url(#${block.svg.getClipPathId()})`);
+        dots.attr("class", this.markerDotClass)
+            .attr("cx", (d) => attrs.cx(d))
+            .attr("cy", (d) => attrs.cy(d))
+            .attr("r", styles.normal.size.radius)
+            .style("stroke-width", styles.normal.size.borderSize)
+            .style("fill", "white")
+            .style("clip-path", `url(#${block.svg.getClipPathId()})`);
     }
 }
-MarkDot.markerDotClass = NamesHelper.getClassName('dot');
-MarkDot.hiddenDotClass = NamesHelper.getClassName('dot-hidden');
+MarkDot.markerDotClass = NamesHelper.getClassName("dot");
+MarkDot.hiddenDotClass = NamesHelper.getClassName("dot-hidden");

package/lib/engine/features/markDots/markDotsHelper.js

@@ -3,13 +3,13 @@ import { Scale } from "../scale/scale";
 export class MarkDotHelper {
     static getDotAttrs(keyAxisOrient, scales, margin, keyField, valueField, isSegmented) {
         const attrs = { cx: null, cy: null };
-        if (keyAxisOrient === 'left' || keyAxisOrient === 'right') {
-            attrs.cx = d => scales.value(d[valueField]) + margin.left;
-            attrs.cy = d => Scale.getScaledValue(scales.key, Helper.getKeyFieldValue(d, keyField, isSegmented)) + margin.top;
+        if (keyAxisOrient === "left" || keyAxisOrient === "right") {
+            attrs.cx = (d) => scales.value(d[valueField]) + margin.left;
+            attrs.cy = (d) => Scale.getScaledValue(scales.key, Helper.getKeyFieldValue(d, keyField, isSegmented)) + margin.top;
         }
-        else if (keyAxisOrient === 'bottom' || keyAxisOrient === 'top') {
-            attrs.cx = d => Scale.getScaledValue(scales.key, Helper.getKeyFieldValue(d, keyField, isSegmented)) + margin.left;
-            attrs.cy = d => scales.value(d[valueField]) + margin.top;
+        else if (keyAxisOrient === "bottom" || keyAxisOrient === "top") {
+            attrs.cx = (d) => Scale.getScaledValue(scales.key, Helper.getKeyFieldValue(d, keyField, isSegmented)) + margin.left;
+            attrs.cy = (d) => scales.value(d[valueField]) + margin.top;
         }
         return attrs;
     }

package/lib/engine/features/recordOverflowAlert/recordOverflowAlertCore.js

@@ -1,17 +1,17 @@
 class RecordOverflowAlertCoreClass {
     constructor() {
-        this.blockClass = 'record-overflow-alert';
+        this.blockClass = "record-overflow-alert";
     }
     render(block, options) {
-        const alertBlock = block.getWrapper()
-            .append('div')
-            .attr('class', this.blockClass)
+        const alertBlock = block
+            .getWrapper()
+            .append("div")
+            .attr("class", this.blockClass)
             .text(this.getAlertText(options));
         this.setAlertPosition(alertBlock, options.positionAttrs);
     }
     update(block, options) {
-        let alertBlock = block.getWrapper()
-            .select(`div.${this.blockClass}`);
+        let alertBlock = block.getWrapper().select(`div.${this.blockClass}`);
         if (alertBlock.empty()) {
             if (options.hidedRecordsAmount === 0)
                 return;
@@ -40,11 +40,11 @@ class RecordOverflowAlertCoreClass {
     }
     setAlertPosition(alertBlock, attrs) {
         alertBlock
-            .style('position', 'absolute')
-            .style('left', attrs.left)
-            .style('right', attrs.right)
-            .style('top', attrs.top)
-            .style('bottom', attrs.bottom);
+            .style("position", "absolute")
+            .style("left", attrs.left)
+            .style("right", attrs.right)
+            .style("top", attrs.top)
+            .style("bottom", attrs.bottom);
     }
 }
 export const RecordOverflowAlertCore = new RecordOverflowAlertCoreClass();

package/lib/engine/features/scale/scale.d.ts

@@ -1,6 +1,6 @@
-import { ScaleLinear, ScaleTime } from 'd3-scale';
-import { AxisScale } from 'd3-axis';
-import { BarChartSettings, ScaleKeyModel, ScaleValueModel } from '../../../model/model';
+import { ScaleLinear } from "d3-scale";
+import { AxisScale } from "d3-axis";
+import { BarChartSettings, ScaleKeyModel, ScaleValueModel } from "../../../model/model";
 export interface Scales {
     key: AxisScale<any>;
     value: AxisScale<any>;
@@ -11,12 +11,11 @@ export interface ScalesWithSecondary extends Scales {
 export declare class Scale {
     static getScales(scaleKey: ScaleKeyModel, scaleValue: ScaleValueModel, bandSettings: BarChartSettings): Scales;
     static getScalesWithSecondary(scaleKey: ScaleKeyModel, scaleValue: ScaleValueModel, scaleValueSecondary: ScaleValueModel, bandSettings: BarChartSettings): ScalesWithSecondary;
-    static getScaleValue(scaleValue: ScaleValueModel): ScaleLinear<number, number, never> | ScaleTime<number, number, never>;
+    static getScaleValue(scaleValue: ScaleValueModel): ScaleLinear<number, number, never>;
     static getScaleBandWidth(scale: AxisScale<any>): number;
     static getScaleStep(scale: AxisScale<any>): number;
     static getScaledValue(scale: AxisScale<any>, value: any): number;
     private static getScaleBand;
     private static getScaleLinear;
     private static getScalePoint;
-    private static getScaleTime;
 }

package/lib/engine/features/scale/scale.js

@@ -1,13 +1,13 @@
-import { scaleBand, scaleLinear, scalePoint, scaleTime } from 'd3-scale';
+import { scaleBand, scaleLinear, scalePoint } from "d3-scale";
 export class Scale {
     static getScales(scaleKey, scaleValue, bandSettings) {
         const scales = {
             key: null,
             value: null
         };
-        if (scaleKey.type === 'band')
+        if (scaleKey.type === "band")
             scales.key = this.getScaleBand(scaleKey.domain, scaleKey.range, bandSettings, scaleKey.elementsAmount);
-        else if (scaleKey.type === 'point')
+        else if (scaleKey.type === "point")
             scales.key = this.getScalePoint(scaleKey.domain, scaleKey.range);
         scales.value = this.getScaleValue(scaleValue);
         return scales;
@@ -17,10 +17,7 @@ export class Scale {
         return Object.assign(Object.assign({}, scales), (scaleValueSecondary && { valueSecondary: this.getScaleValue(scaleValueSecondary) }));
     }
     static getScaleValue(scaleValue) {
-        if (scaleValue.type === 'linear')
-            return this.getScaleLinear(scaleValue.domain, scaleValue.range);
-        else if (scaleValue.type === 'datetime')
-            return this.getScaleTime(scaleValue.domain, scaleValue.range);
+        return this.getScaleLinear(scaleValue.domain, scaleValue.range);
     }
     static getScaleBandWidth(scale) {
         if (scale.bandwidth && scale.bandwidth() !== 0) {
@@ -42,40 +39,34 @@ export class Scale {
         return scale(value);
     }
     static getScaleBand(domain, range, bandSettings, elementsInGroupAmount) {
-        const scale = scaleBand()
-            .domain(domain)
-            .range([range.start, range.end]);
+        const scale = scaleBand().domain(domain).range([range.start, range.end]);
         const bandSize = scale.bandwidth();
         if (bandSettings.groupMinDistance < bandSize) {
             scale.paddingInner(bandSettings.groupMinDistance / bandSize);
             scale.paddingOuter(bandSettings.groupMinDistance / bandSize / 2);
         }
-        // Padding inner = 10. If bandwidth more than needed, paddingInner is increased to number less than 35 
+        // Padding inner = 10. If bandwidth more than needed, paddingInner is increased to number less than 35
         let paddingInner = bandSettings.groupMinDistance;
-        while (scale.bandwidth() > bandSettings.maxBarWidth * elementsInGroupAmount + bandSettings.barDistance * (elementsInGroupAmount - 1) && paddingInner < bandSettings.groupMaxDistance) {
+        while (scale.bandwidth() >
+            bandSettings.maxBarWidth * elementsInGroupAmount +
+                bandSettings.barDistance * (elementsInGroupAmount - 1) &&
+            paddingInner < bandSettings.groupMaxDistance) {
             scale.paddingInner(++paddingInner / bandSize);
         }
         // if bandwidth more than all bars widths in group + distance between it + distance between groups
         let paddingOuter = 1;
-        while (scale.step() > bandSettings.maxBarWidth * elementsInGroupAmount + bandSettings.groupMaxDistance + bandSettings.barDistance * (elementsInGroupAmount - 1)) {
+        while (scale.step() >
+            bandSettings.maxBarWidth * elementsInGroupAmount +
+                bandSettings.groupMaxDistance +
+                bandSettings.barDistance * (elementsInGroupAmount - 1)) {
             scale.paddingOuter(++paddingOuter / bandSize);
         }
         return scale;
     }
     static getScaleLinear(domain, range) {
-        return scaleLinear()
-            .domain(domain)
-            .range([range.start, range.end]);
+        return scaleLinear().domain(domain).range([range.start, range.end]);
     }
     static getScalePoint(domain, range) {
-        return scalePoint()
-            .domain(domain)
-            .range([range.start, range.end]);
-    }
-    static getScaleTime(domain, range) {
-        return scaleTime()
-            .domain(domain)
-            .range([range.start, range.end])
-            .nice();
+        return scalePoint().domain(domain).range([range.start, range.end]);
     }
 }

package/lib/engine/features/tipBox/tipBox.d.ts

@@ -1,6 +1,6 @@
-import { Selection } from 'd3-selection';
+import { Selection } from "d3-selection";
 import { Block } from "../../block/block";
-import { BlockMargin } from '../../../model/model';
+import { BlockMargin } from "../../../model/model";
 import { Size } from "../../../config/config";
 export declare class TipBox {
     static readonly tipBoxClass = "tipbox";

package/lib/engine/features/tipBox/tipBox.js

@@ -1,4 +1,4 @@
-import { TipBoxHelper } from './tipBoxHelper';
+import { TipBoxHelper } from "./tipBoxHelper";
 export class TipBox {
     static renderOrGet(block, margin, blockSize) {
         const attributes = TipBoxHelper.getAttributes(margin, blockSize);
@@ -8,25 +8,21 @@ export class TipBox {
         return block.getSvg().select(`.${this.tipBoxClass}`);
     }
     static clearEvents(block) {
-        block.getSvg()
-            .select(`.${this.tipBoxClass}`)
-            .on('mousemove', null)
-            .on('mouseleave', null)
-            .on('click', null);
+        block.getSvg().select(`.${this.tipBoxClass}`).on("mousemove", null).on("mouseleave", null).on("click", null);
     }
     static renderBlock(block, attributes) {
-        let tipBox = block.getSvg()
-            .select(`rect.${this.tipBoxClass}`);
+        let tipBox = block.getSvg().select(`rect.${this.tipBoxClass}`);
         if (tipBox.empty())
-            tipBox = block.getSvg()
-                .append('rect')
-                .attr('class', this.tipBoxClass)
-                .attr('x', attributes.x)
-                .attr('y', attributes.y)
-                .attr('width', attributes.width)
-                .attr('height', attributes.height)
-                .style('opacity', 0);
+            tipBox = block
+                .getSvg()
+                .append("rect")
+                .attr("class", this.tipBoxClass)
+                .attr("x", attributes.x)
+                .attr("y", attributes.y)
+                .attr("width", attributes.width)
+                .attr("height", attributes.height)
+                .style("opacity", 0);
         return tipBox;
     }
 }
-TipBox.tipBoxClass = 'tipbox';
+TipBox.tipBoxClass = "tipbox";

package/lib/engine/features/tipBox/tipBoxHelper.js

@@ -13,14 +13,14 @@ export class TipBoxHelper {
             x: margin.left - pad,
             y: margin.top - pad,
             width: blockSize.width - margin.left - margin.right + pad * 2,
-            height: blockSize.height - margin.top - margin.bottom + pad * 2,
+            height: blockSize.height - margin.top - margin.bottom + pad * 2
         };
     }
     static getKeyIndex(pointer, chartOrient, margin, blockSize, scaleKey, scaleKeyType) {
-        const pointerAxisType = chartOrient === 'vertical' ? 0 : 1; // 0 - координата поинтера по оси x, 1 - по оси y
-        const marginByOrient = chartOrient === 'vertical' ? margin.left : margin.top;
+        const pointerAxisType = chartOrient === "vertical" ? 0 : 1; // 0 - координата поинтера по оси x, 1 - по оси y
+        const marginByOrient = chartOrient === "vertical" ? margin.left : margin.top;
         const scaleStep = Scale.getScaleStep(scaleKey);
-        if (scaleKeyType === 'point') {
+        if (scaleKeyType === "point") {
             return this.getKeyIndexOfPoint(pointer, scaleStep, marginByOrient, pointerAxisType);
         }
         else {
@@ -34,7 +34,7 @@ export class TipBoxHelper {
         return Math.floor(point / scaleStep);
     }
     static getKeyIndexOfBand(pointer, scaleStep, marginByOrient, pointerAxisType, blockSize, margin, chartOrient, scaleKey) {
-        const chartBlockSizeByDir = chartOrient === 'vertical'
+        const chartBlockSizeByDir = chartOrient === "vertical"
             ? blockSize.width - margin.left - margin.right
             : blockSize.height - margin.top - margin.bottom;
         const outerPadding = chartBlockSizeByDir - scaleStep * scaleKey.domain().length;

package/lib/engine/features/title/title.d.ts

@@ -1,4 +1,4 @@
-import { Size } from '../../../config/config';
+import { Size } from "../../../config/config";
 import { OptionsModelTitle, TitleBlockModel } from "../../../model/model";
 import { Block } from "../../block/block";
 export declare class Title {

package/lib/engine/features/title/title.js

@@ -1,11 +1,9 @@
-import { DomHelper } from '../../helpers/domHelper';
+import { DomHelper } from "../../helpers/domHelper";
 export class Title {
     static render(block, title, titleBlockModel, blockSize) {
         if (!title.textContent)
             return;
-        const titleBlock = block.getSvg()
-            .append('text')
-            .attr('class', this.titleCssClass);
+        const titleBlock = block.getSvg().append("text").attr("class", this.titleCssClass);
         const titleCoordinate = this.getTitleAttributes(blockSize, titleBlockModel);
         this.fillTitleBlockAttributes(titleBlock, titleCoordinate, title);
         this.setTitleTooltip(titleBlock, title.textContent);
@@ -15,11 +13,11 @@ export class Title {
     }
     static fillTitleBlockAttributes(titleBlock, attributes, title) {
         titleBlock
-            .attr('x', attributes.x)
-            .attr('y', attributes.y)
-            .attr('dominant-baseline', attributes.dominantBaseline)
+            .attr("x", attributes.x)
+            .attr("y", attributes.y)
+            .attr("dominant-baseline", attributes.dominantBaseline)
             .text(title.textContent)
-            .style('font-size', `${title.fontSize}px`);
+            .style("font-size", `${title.fontSize}px`);
         DomHelper.cropSvgLabels(titleBlock, attributes.maxWidth);
     }
     static getTitleAttributes(blockSize, titleBlockModel) {
@@ -35,8 +33,7 @@ export class Title {
         return coordinate;
     }
     static setTitleTooltip(titleBlock, text) {
-        titleBlock.append('title')
-            .text(text);
+        titleBlock.append("title").text(text);
     }
 }
-Title.titleCssClass = 'chart-title';
+Title.titleCssClass = "chart-title";

package/lib/engine/features/tolltip/newTooltip/newTooltip.d.ts

@@ -1,4 +1,4 @@
-import { Selection } from 'd3-selection';
+import { Selection } from "d3-selection";
 export interface TooltipCoordinate {
     left: string;
     top: string;

package/lib/engine/features/tolltip/newTooltip/newTooltip.js

@@ -7,9 +7,7 @@ export class NewTooltip {
         return this.elSelection;
     }
     render(wrapper) {
-        this.elSelection = wrapper
-            .append('div')
-            .attr('class', NewTooltip.tooltipBlockClass);
+        this.elSelection = wrapper.append("div").attr("class", NewTooltip.tooltipBlockClass);
         return this.elSelection;
     }
     appendContent(content) {
@@ -17,10 +15,10 @@ export class NewTooltip {
     }
     setCoordinate(coordinate) {
         this.elSelection
-            .style('right', coordinate.right)
-            .style('bottom', coordinate.bottom)
-            .style('left', coordinate.left)
-            .style('top', coordinate.top);
+            .style("right", coordinate.right)
+            .style("bottom", coordinate.bottom)
+            .style("left", coordinate.left)
+            .style("top", coordinate.top);
     }
 }
-NewTooltip.tooltipBlockClass = 'mdt-charts-tooltip-block';
+NewTooltip.tooltipBlockClass = "mdt-charts-tooltip-block";

package/lib/engine/features/tolltip/tooltip.d.ts

@@ -1,8 +1,8 @@
 import { Model, PolarOptionsModel, TwoDimensionalOptionsModel } from "../../../model/model";
 import { Block } from "../../block/block";
 import { MdtChartsDataSource } from "../../../config/config";
-import { Scales } from '../scale/scale';
-import { TooltipSettings } from '../../../designer/designerConfig';
+import { Scales } from "../scale/scale";
+import { TooltipSettings } from "../../../designer/designerConfig";
 export declare class Tooltip {
     static readonly tooltipBlockClass: string;
     static readonly tooltipLineClass = "mdt-charts-tooltip-line";