axidio-styleguide-library1-v2 0.2.20 → 0.2.21

package/fesm2022/axidio-styleguide-library1-v2.mjs

@@ -3014,344 +3014,205 @@ class GuageChartComponent extends ComponentUniqueId {
             svgHeight: 80,
             low_colorMap: ['#43CC00', '#FFEF0C', '#FF4E0C'],
             high_colorMap: ['#FF4E0C', '#FFEF0C', '#43CC00'],
-            isHeaderVisible: undefined,
             pointerWidth: 10,
             pointerTailLength: 5,
             pointerHeadLengthPercent: 0.7,
             labelInset: 10,
             legendJustified: false,
             backgroundColor: '#FFFFFF',
-            isDrilldownChart: undefined,
             ringScaleFactor: 0,
             textsAtCenterScaleFactor: 0,
             currentValueWidthScaleFactor: 60,
             currentValueHeightScaleFactor: 30,
             pointerColor: '#686868',
-            isToggleVisible: undefined,
-            selectedKpiTooltop: undefined,
-            isValueLableAdjust: undefined,
-            isTitleHidden: undefined,
             headerMenuOptions: HeaderConfigHelper.headerConfig.headerMenuOptions,
         };
     }
     get isAlertEnabled() {
-        return this.chartConfiguration?.headerMenuOptions?.some(option => option.id === 'editAlert');
+        return (this.chartConfiguration?.headerMenuOptions?.some((option) => option.id === 'editAlert') ?? false);
     }
-    ngOnChanges() {
-        let self = this;
-        d3.select('#' + self.uniqueId).remove();
-        this.initializeLineChart();
+    ngOnInit() {
+        this.buildChart();
+    }
+    ngOnChanges(changes) {
+        if (changes['chartData'] || changes['customChartConfiguration']) {
+            this.rebuildChart();
+        }
     }
     onResized(event) {
-        let self = this;
-        d3.select('#' + self.uniqueId).remove();
-        this.initializeLineChart();
+        this.rebuildChart();
     }
-    ngOnInit() { }
-    initializeLineChart() {
-        var self = this;
-        let data = [];
-        let metaData = null;
-        let colorMaps = [];
-        let angleValue = [];
-        let data_ready = [];
-        let labelArray = [];
-        let colorType = null;
-        let isria = this.customChartConfiguration.isRia;
-        for (var i in this.defaultConfiguration) {
-            this.chartConfiguration[i] = ChartHelper.getValueByConfigurationType(i, this.defaultConfiguration, this.customChartConfiguration);
-        }
-        data = this.chartData.data;
-        metaData = this.chartData.metaData;
-        colorType = metaData.colorType;
-        if (colorType == 'low') {
-            colorMaps = this.chartConfiguration.low_colorMap;
-        }
-        else {
-            colorMaps = this.chartConfiguration.high_colorMap;
-        }
+    rebuildChart() {
+        d3.select(`#${this.uniqueId}`).remove();
+        this.buildChart();
+    }
+    buildChart() {
+        if (!this.chartData?.data || !this.chartData?.metaData)
+            return;
+        this.mergeConfigurations();
+        this.processDataAndRender();
+    }
+    mergeConfigurations() {
+        Object.keys(this.defaultConfiguration).forEach((key) => {
+            this.chartConfiguration[key] = ChartHelper.getValueByConfigurationType(key, this.defaultConfiguration, this.customChartConfiguration);
+        });
+        this.isHeaderVisible =
+            this.chartConfiguration.isHeaderVisible ?? this.isHeaderVisible;
+    }
+    processDataAndRender() {
+        const { data, metaData } = this.chartData;
+        const colorMap = metaData.colorType === 'low'
+            ? this.chartConfiguration.low_colorMap
+            : this.chartConfiguration.high_colorMap;
+        this.setDataType(metaData);
+        const diffs = data.slice(1).map((v, i) => v - data[i]);
+        const total = diffs.reduce((sum, val) => sum + val, 0);
+        const angles = this.computeAngles(diffs, total);
+        const container = d3.select(this.containerElt.nativeElement);
+        const width = parseInt(container.style('width')) -
+            this.chartConfiguration.margin.left -
+            this.chartConfiguration.margin.right;
+        const height = parseInt(d3.select(this.guagecontainerElt.nativeElement).style('height')) -
+            this.chartConfiguration.margin.top -
+            this.chartConfiguration.margin.bottom -
+            56;
+        const radius = Math.min(width, height) / 2;
+        const svg = this.createSvg(container, width, height, radius);
+        this.drawArcs(svg, diffs, data, angles, colorMap, metaData, radius);
+        this.drawPointer(svg, data, metaData, radius);
+        this.drawLabels(svg, data, diffs, metaData, radius);
+        this.drawTextBlocks(svg, metaData, radius);
+    }
+    setDataType(metaData) {
         if (metaData.dataType) {
-            this.dataType = metaData.dataType;
-            if (this.dataType == 'USD') {
-                this.datatype_status = true;
-                this.dataType = '$ ';
-            }
+            this.dataType = metaData.dataType === 'USD' ? '$ ' : metaData.dataType;
+            this.datatype_status = metaData.dataType === 'USD';
         }
-        data.map(function (dataUnit, i) {
-            if (i < data.length - 1) {
-                let diff = data[i + 1] - data[i];
-                data_ready.push(diff);
-            }
-        });
-        var chartContainer = d3.select(this.containerElt.nativeElement);
-        var guagecontainer = d3.select(this.guagecontainerElt.nativeElement);
-        var margin = this.chartConfiguration.margin;
-        var width = parseInt(chartContainer.style('width')) - margin.left - margin.right;
-        var height = parseInt(guagecontainer.style('height')) -
-            margin.top -
-            margin.bottom -
-            56; //chart header height
-        if (this.chartConfiguration.isHeaderVisible != undefined)
-            this.isHeaderVisible = this.chartConfiguration.isHeaderVisible;
-        var svg = chartContainer
+    }
+    computeAngles(values, total) {
+        return values.reduce((acc, unit, i) => {
+            const angle = (unit / total) * 180;
+            acc.push(i === 0 ? angle : acc[i - 1] + angle);
+            return acc;
+        }, []);
+    }
+    createSvg(container, width, height, radius) {
+        return container
             .append('svg')
-            .attr('id', self.uniqueId)
-            .attr('width', width + margin.left + margin.right)
-            .attr('height', height + margin.top + margin.bottom)
+            .attr('id', this.uniqueId)
+            .attr('width', width + this.chartConfiguration.margin.left)
+            .attr('height', height + this.chartConfiguration.margin.top)
             .call(ChartHelper.responsivefy)
-            .append('g');
-        var radius = Math.min(width, height) / 2;
-        if (this.chartConfiguration.isDrilldownChart) {
-            this.chartConfiguration.currentValueWidthScaleFactor += 40;
-            this.chartConfiguration.currentValueHeightScaleFactor += 20;
-        }
-        else {
-            if (window.innerWidth > 1400) {
-                this.chartConfiguration.currentValueHeightScaleFactor += 15;
-                this.chartConfiguration.currentValueWidthScaleFactor *= 2;
-            }
-        }
-        let topTextPosition = radius / 2 - 10;
-        let midTextPosition = topTextPosition + this.chartConfiguration.currentValueHeightScaleFactor;
-        let bottomTextPosition = midTextPosition + this.chartConfiguration.currentValueHeightScaleFactor;
-        var data_length = data.length;
-        function deg2rad(deg) {
-            return (deg * Math.PI) / 180;
-        }
-        let tempArray = [];
-        let total = 0;
-        data_ready.map(function (unit) {
-            total += unit;
-        });
-        data_ready.map(function (unit, i) {
-            var angle = (unit / total) * 180;
-            if (i === 0) {
-                tempArray.push(angle);
-            }
-            else {
-                let currentAngle = tempArray[i - 1] + angle;
-                tempArray.push(currentAngle);
-            }
-        });
-        angleValue = tempArray;
-        var arc = d3
+            .append('g')
+            .attr('transform', `translate(${(parseInt(container.style('width')) / 2 - radius) +
+            this.chartConfiguration.margin.left},${this.chartConfiguration.margin.top})`);
+    }
+    drawArcs(svg, diffs, data, angles, colorMap, metaData, radius) {
+        const arc = d3
             .arc()
             .innerRadius(radius -
-            self.chartConfiguration.ringWidth -
-            self.chartConfiguration.ringInset)
+            this.chartConfiguration.ringWidth -
+            this.chartConfiguration.ringInset)
             .outerRadius(radius)
-            .startAngle(function (d, i) {
-            var ratio;
-            if (i === 0) {
-                ratio = self.chartConfiguration.minAngle;
-            }
-            else {
-                ratio = self.chartConfiguration.minAngle + angleValue[i - 1];
-            }
-            return deg2rad(ratio);
-        })
-            .endAngle(function (d, i) {
-            var ratio;
-            if (i === data_ready.length - 1) {
-                ratio = self.chartConfiguration.maxAngle;
-            }
-            else {
-                ratio = self.chartConfiguration.minAngle + angleValue[i];
-            }
-            return deg2rad(ratio);
-        });
-        function centerTranslation() {
-            return 'translate(' + radius + ',' + radius + ')';
-        }
-        var centerTx = centerTranslation();
-        var tickData = d3
-            .range(self.chartConfiguration.majorTicks)
-            .map(function (i) {
-            return 1 / self.chartConfiguration.majorTicks;
-        });
-        var arcs = svg.append('g').attr('class', 'arc').attr('transform', centerTx);
+            .startAngle((_, i) => this.deg2rad(i === 0
+            ? this.chartConfiguration.minAngle
+            : this.chartConfiguration.minAngle + angles[i - 1]))
+            .endAngle((_, i) => this.deg2rad(i === diffs.length - 1
+            ? this.chartConfiguration.maxAngle
+            : this.chartConfiguration.minAngle + angles[i]));
+        const arcs = svg
+            .append('g')
+            .attr('class', 'arc')
+            .attr('transform', `translate(${radius},${radius})`);
         arcs
             .selectAll('path')
-            .data(data_ready)
+            .data(diffs)
             .enter()
             .append('path')
-            .on('click', function (d) {
-            if (!metaData.hasDrillDown || metaData.currentValue == 0) {
-                return;
-            }
-            let range = getRange(d);
-            self.handleClick(range);
-        })
-            .attr('fill', function (d, i) {
-            return colorMaps[i];
-        })
-            .attr('id', function (d, i) {
-            return colorMaps[i];
-        })
             .attr('d', arc)
-            // .style('cursor', 'pointer');
-            .style('cursor', function (d) {
-            if (metaData.currentValue > 0 && metaData.hasDrillDown && !isria)
-                return 'pointer';
-            else
-                return 'default';
+            .attr('fill', (_, i) => colorMap[i])
+            .style('cursor', () => metaData.currentValue > 0 && metaData.hasDrillDown
+            ? 'pointer'
+            : 'default')
+            .on('click', (event, d) => {
+            if (metaData.hasDrillDown && metaData.currentValue > 0) {
+                this.handleClick(`${data[0]} - ${data[data.length - 1]}`);
+            }
         });
-        let getRange = function (d) {
-            let index = data_ready.indexOf(d);
-            return data[0] + ' and ' + data[data.length - 1];
-        };
-        let pointerHeadLength = Math.round(radius * self.chartConfiguration.pointerHeadLengthPercent);
-        var lineData = [
-            [self.chartConfiguration.pointerWidth / 2, 0],
+    }
+    drawPointer(svg, data, metaData, radius) {
+        const pointerHeadLength = Math.round(radius * this.chartConfiguration.pointerHeadLengthPercent);
+        const pointerValue = metaData.currentValue - data[0];
+        const range = data[data.length - 1] - data[0];
+        const angle = this.chartConfiguration.minAngle + (pointerValue / range) * 180;
+        const lineData = [
+            [this.chartConfiguration.pointerWidth / 2, 0],
             [0, -pointerHeadLength],
-            [-(self.chartConfiguration.pointerWidth / 2), 0],
-            [0, self.chartConfiguration.pointerTailLength],
-            [self.chartConfiguration.pointerWidth / 2, 0],
+            [-this.chartConfiguration.pointerWidth / 2, 0],
+            [0, this.chartConfiguration.pointerTailLength],
+            [this.chartConfiguration.pointerWidth / 2, 0],
         ];
-        var pointerLine = d3.line();
-        var pg = svg
+        const pointerLine = d3.line();
+        svg
             .append('g')
-            .data([lineData])
             .attr('class', 'pointer')
-            .attr('transform', centerTx);
-        var pointerValue = metaData.currentValue - data[0];
-        var range = data[data_length - 1] - data[0];
-        var pointerAngle = self.chartConfiguration.minAngle + (pointerValue / range) * 180;
-        pg.append('path')
-            .attr('d', pointerLine)
-            .attr('fill', self.chartConfiguration.pointerColor)
-            .attr('transform', 'rotate(' +
-            pointerAngle +
-            ') translate(0,' +
-            (-radius + self.chartConfiguration.ringWidth + pointerHeadLength) +
-            ')');
-        var lg = svg.append('g').attr('class', 'label').attr('transform', centerTx);
-        let labelArrayTemp = [{ name: data[0], value: 0 }];
-        let count = 0;
-        data_ready.map(function (dataUnit, i) {
-            count += dataUnit;
-            let temp = { name: data[i + 1], value: count };
-            labelArrayTemp.push(temp);
+            .attr('transform', `translate(${radius},${radius})`)
+            .append('path')
+            .attr('d', pointerLine(lineData))
+            .attr('fill', this.chartConfiguration.pointerColor)
+            .attr('transform', `rotate(${angle}) translate(0,${-radius + this.chartConfiguration.ringWidth + pointerHeadLength})`);
+    }
+    drawLabels(svg, data, diffs, metaData, radius) {
+        const range = data[data.length - 1] - data[0];
+        let cumulative = 0;
+        const labelArray = [{ name: data[0], value: 0 }];
+        diffs.forEach((diff, i) => {
+            cumulative += diff;
+            labelArray.push({ name: data[i + 1], value: cumulative });
         });
-        labelArray = labelArrayTemp;
-        lg.selectAll('.bubble')
+        const labels = svg
+            .append('g')
+            .attr('class', 'label')
+            .attr('transform', `translate(${radius},${radius})`);
+        labels
+            .selectAll('text')
             .data(labelArray)
             .enter()
-            .append('g')
-            .attr('transform', function (d) {
-            var newAngle = self.chartConfiguration.minAngle + (d.value / range) * 180;
-            return ('rotate(' +
-                newAngle +
-                ') translate(0,' +
-                (self.chartConfiguration.labelInset - radius - 20) +
-                ')');
-        })
-            .append('g')
-            .attr('transform', function (d, i) {
-            var newAngle = self.chartConfiguration.minAngle + (d.value / range) * 180;
-            if (i == 0 && self.chartConfiguration.isValueLableAdjust) {
-                return 'rotate(' + (0 - newAngle) + ') translate(-27,0)';
-            }
-            if (i == labelArray.length - 1 &&
-                self.chartConfiguration.isValueLableAdjust) {
-                return 'rotate(' + (0 - newAngle) + ') translate(-15,0)';
-            }
-            return 'rotate(' + (0 - newAngle) + ') translate(-17,0)';
-        })
             .append('text')
-            .attr('style', function (d) {
-            if (window.innerWidth < 1400)
-                return 'font-size: ' + '12px' + '; font-weight:' + '600;';
-            else
-                return 'font-size: ' + '14px' + '; font-weight:' + '600;';
+            .attr('transform', (d) => {
+            const newAngle = this.chartConfiguration.minAngle + (d.value / range) * 180;
+            return `rotate(${newAngle}) translate(0,${this.chartConfiguration.labelInset - radius - 20}) rotate(${-newAngle})`;
         })
             .attr('fill', 'var(--chart-text-color)')
-            .text(function (d) {
-            if (metaData.dataType) {
-                return d.name + metaData.dataType;
-            }
-            return d.name;
-        });
-        svg
-            .append('foreignObject')
-            .attr('transform', 'translate(' +
-            (radius - this.chartConfiguration.currentValueWidthScaleFactor / 2) +
-            ',' +
-            topTextPosition +
-            ')')
-            .attr('width', this.chartConfiguration.currentValueWidthScaleFactor + 8)
-            .attr('height', this.chartConfiguration.currentValueHeightScaleFactor)
-            .append('xhtml:div')
-            .attr('class', 'value-display')
-            .style('height', this.chartConfiguration.currentValueHeightScaleFactor + 10 + 'px')
-            .style('font-size', function () {
-            if (window.innerWidth > 1500) {
-                self.chartConfiguration.currentValueHeightScaleFactor - 25 + 'px';
-            }
-            else {
-                self.chartConfiguration.currentValueHeightScaleFactor - 15 + 'px';
-            }
-        })
-            .html(metaData.currentValue + metaData.dataType);
-        if (metaData.status) {
-            let widthTemp = metaData.status.length > 4 ? 210 : 120;
+            .style('font-size', window.innerWidth < 1400 ? '12px' : '14px')
+            .style('font-weight', 600)
+            .text((d) => `${d.name}${metaData.dataType ?? ''}`);
+    }
+    drawTextBlocks(svg, metaData, radius) {
+        const top = radius / 2 - 10;
+        const mid = top + this.chartConfiguration.currentValueHeightScaleFactor;
+        const bottom = mid + this.chartConfiguration.currentValueHeightScaleFactor;
+        const addText = (cls, text, y, width = 210) => {
             svg
                 .append('foreignObject')
-                .attr('transform', 'translate(' + (radius - widthTemp / 2) + ',' + midTextPosition + ')')
-                .attr('width', widthTemp)
-                .attr('height', this.chartConfiguration.currentValueHeightScaleFactor + 10)
+                .attr('transform', `translate(${radius - width / 2},${y})`)
+                .attr('width', width)
+                .attr('height', this.chartConfiguration.currentValueHeightScaleFactor)
                 .append('xhtml:div')
-                .attr('class', 'status-display')
-                .style('font-size', this.chartConfiguration.currentValueHeightScaleFactor - 25 + 'px')
-                .html(metaData.status);
-        }
-        svg
-            .append('foreignObject')
-            .attr('transform', 'translate(' + (radius - 105) + ',' + bottomTextPosition + ')')
-            .attr('width', 210)
-            .attr('height', this.chartConfiguration.currentValueHeightScaleFactor)
-            .append('xhtml:div')
-            .attr('class', 'daterange-display')
-            .style('font-size', function () {
-            if (self.chartConfiguration.isDrilldownChart) {
-                {
-                    if (window.innerWidth < 1400)
-                        return '14px';
-                    else
-                        return '18px';
-                }
-            }
-            else {
-                if (window.innerWidth < 1400)
-                    return '14px';
-                else
-                    return '18px';
-            }
-        })
-            .html(function () {
-            var desiredSize;
-            if (window.innerWidth < 1400)
-                desiredSize = '14px';
-            else
-                desiredSize = '18px';
-            if (metaData.dateRange)
-                return ('<span class="marginright-3"><i class="fa fa-calendar"></i></span><span> ' +
-                    metaData.dateRange +
-                    '</span>');
-            else
-                return '';
-        });
-        var containerMidWidth = parseInt(chartContainer.style('width')) / 2;
-        var nodeHalfWidth = svg.node().getBoundingClientRect().width / 2;
-        var updatedStartingPoint = containerMidWidth - nodeHalfWidth;
-        svg.attr('transform', 'translate(' +
-            (updatedStartingPoint + margin.left) +
-            ',' +
-            margin.top +
-            ')');
+                .attr('class', cls)
+                .html(text);
+        };
+        addText('value-display', `${metaData.currentValue}${metaData.dataType ?? ''}`, top);
+        if (metaData.status)
+            addText('status-display', metaData.status, mid);
+        if (metaData.dateRange)
+            addText('daterange-display', `<i class="fa fa-calendar"></i> ${metaData.dateRange}`, bottom);
     }
-    handleClick(d) {
-        this.clickEvent.emit(d);
+    deg2rad(deg) {
+        return (deg * Math.PI) / 180;
+    }
+    handleClick(data) {
+        this.clickEvent.emit(data);
     }
     handleHeaderMenuClick(id) {
         this.headerMenuclickEvent.emit(id);