axidio-styleguide-library1-v2 0.2.9 → 0.2.11

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

@@ -3035,259 +3035,321 @@ class GuageChartComponent extends ComponentUniqueId {
         };
     }
     get isAlertEnabled() {
-        return this.chartConfiguration?.headerMenuOptions?.some((option) => option.id === 'editAlert');
+        return this.chartConfiguration?.headerMenuOptions?.some(option => option.id === 'editAlert');
     }
-    ngOnInit() { }
     ngOnChanges() {
-        d3.select('#' + this.uniqueId).remove();
+        let self = this;
+        d3.select('#' + self.uniqueId).remove();
         this.initializeLineChart();
     }
     onResized(event) {
-        d3.select('#' + this.uniqueId).remove();
+        let self = this;
+        d3.select('#' + self.uniqueId).remove();
         this.initializeLineChart();
     }
-    /** -------------------------------
-     *  Main Initialization Function
-     *  ------------------------------*/
+    ngOnInit() { }
     initializeLineChart() {
-        const self = this;
-        const { data, metaData } = this.chartData;
-        const isRia = this.customChartConfiguration.isRia;
-        this.setupChartConfiguration();
-        const { colorMaps } = this.getColorMap(metaData);
-        this.configureDataType(metaData);
-        const data_ready = this.calculateDataReady(data);
-        const { chartContainer, guagecontainer, width, height } = this.setupContainer();
-        this.isHeaderVisible =
-            this.chartConfiguration.isHeaderVisible ?? this.isHeaderVisible;
-        const svg = this.createSvg(chartContainer, width, height);
-        const radius = this.adjustDimensionsAndRadius(width, height);
-        const angleValue = this.computeAngles(data_ready, data);
-        const arc = this.createArc(radius, angleValue, data_ready);
-        this.drawGaugeArcs(svg, arc, data_ready, colorMaps, metaData, isRia, data);
-        this.drawPointer(svg, radius, metaData, data);
-        this.drawLabels(svg, radius, data_ready, data, metaData);
-        this.drawCenterTexts(svg, radius, metaData);
-        this.centerSvg(svg, chartContainer, width, height);
-    }
-    /** -------------------------------
-     *  Modular Helper Functions
-     *  ------------------------------*/
-    setupChartConfiguration() {
-        for (const key in this.defaultConfiguration) {
-            this.chartConfiguration[key] = ChartHelper.getValueByConfigurationType(key, this.defaultConfiguration, this.customChartConfiguration);
+        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;
         }
-    }
-    getColorMap(metaData) {
-        const colorType = metaData.colorType;
-        const colorMaps = colorType === 'low'
-            ? this.chartConfiguration.low_colorMap
-            : this.chartConfiguration.high_colorMap;
-        return { colorMaps };
-    }
-    configureDataType(metaData) {
         if (metaData.dataType) {
             this.dataType = metaData.dataType;
-            if (this.dataType === 'USD') {
+            if (this.dataType == 'USD') {
                 this.datatype_status = true;
                 this.dataType = '$ ';
             }
         }
-    }
-    calculateDataReady(data) {
-        const data_ready = [];
-        data.forEach((_, i) => {
+        data.map(function (dataUnit, i) {
             if (i < data.length - 1) {
-                data_ready.push(data[i + 1] - data[i]);
+                let diff = data[i + 1] - data[i];
+                data_ready.push(diff);
             }
         });
-        return data_ready;
-    }
-    setupContainer() {
-        const chartContainer = d3.select(this.containerElt.nativeElement);
-        const guagecontainer = d3.select(this.guagecontainerElt.nativeElement);
-        const margin = this.chartConfiguration.margin;
-        const width = parseInt(chartContainer.style('width')) - margin.left - margin.right;
-        const height = parseInt(guagecontainer.style('height')) -
+        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
-        return { chartContainer, guagecontainer, width, height };
-    }
-    createSvg(chartContainer, width, height) {
-        const margin = this.chartConfiguration.margin;
-        return chartContainer
+            56; //chart header height
+        if (this.chartConfiguration.isHeaderVisible != undefined)
+            this.isHeaderVisible = this.chartConfiguration.isHeaderVisible;
+        var svg = chartContainer
             .append('svg')
-            .attr('id', this.uniqueId)
+            .attr('id', self.uniqueId)
             .attr('width', width + margin.left + margin.right)
             .attr('height', height + margin.top + margin.bottom)
             .call(ChartHelper.responsivefy)
             .append('g');
-    }
-    adjustDimensionsAndRadius(width, height) {
-        const radius = Math.min(width, height) / 2;
+        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;
-        }
-        return radius;
-    }
-    computeAngles(data_ready, data) {
-        const total = data_ready.reduce((sum, val) => sum + val, 0);
-        const tempArray = [];
-        data_ready.forEach((unit, i) => {
-            const angle = (unit / total) * 180;
-            tempArray.push(i === 0 ? angle : tempArray[i - 1] + angle);
+        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;
         });
-        return tempArray;
-    }
-    createArc(radius, angleValue, data_ready) {
-        const self = this;
-        const deg2rad = (deg) => (deg * Math.PI) / 180;
-        return d3
+        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
             .arc()
             .innerRadius(radius -
             self.chartConfiguration.ringWidth -
             self.chartConfiguration.ringInset)
             .outerRadius(radius)
-            .startAngle((_, i) => deg2rad(i === 0
-            ? self.chartConfiguration.minAngle
-            : self.chartConfiguration.minAngle + angleValue[i - 1]))
-            .endAngle((_, i) => deg2rad(i === data_ready.length - 1
-            ? self.chartConfiguration.maxAngle
-            : self.chartConfiguration.minAngle + angleValue[i]));
-    }
-    drawGaugeArcs(svg, arc, data_ready, colorMaps, metaData, isRia, data) {
-        const self = this;
-        const arcs = svg
-            .append('g')
-            .attr('class', 'arc')
-            .attr('transform', this.centerTranslation(arc.outerRadius()()));
+            .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);
         arcs
             .selectAll('path')
             .data(data_ready)
             .enter()
             .append('path')
-            .attr('fill', (_, i) => colorMaps[i])
-            .style('cursor', () => metaData.currentValue > 0 && metaData.hasDrillDown && !isRia
-            ? 'pointer'
-            : 'default')
-            .attr('d', arc)
-            .on('click', (d) => {
-            if (!metaData.hasDrillDown || metaData.currentValue === 0)
+            .on('click', function (d) {
+            if (!metaData.hasDrillDown || metaData.currentValue == 0) {
                 return;
-            const range = `${data[0]} and ${data[data.length - 1]}`;
+            }
+            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';
         });
-    }
-    drawPointer(svg, radius, metaData, data) {
-        const self = this;
-        const pointerHeadLength = Math.round(radius * self.chartConfiguration.pointerHeadLengthPercent);
-        const lineData = [
+        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],
             [0, -pointerHeadLength],
             [-(self.chartConfiguration.pointerWidth / 2), 0],
             [0, self.chartConfiguration.pointerTailLength],
             [self.chartConfiguration.pointerWidth / 2, 0],
         ];
-        const pointerLine = d3.line();
-        const pg = svg
+        var pointerLine = d3.line();
+        var pg = svg
             .append('g')
             .data([lineData])
             .attr('class', 'pointer')
-            .attr('transform', this.centerTranslation(radius));
-        const pointerValue = metaData.currentValue - data[0];
-        const range = data[data.length - 1] - data[0];
-        const pointerAngle = self.chartConfiguration.minAngle + (pointerValue / range) * 180;
+            .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})`);
-    }
-    drawLabels(svg, radius, data_ready, data, metaData) {
-        const self = this;
-        const range = data[data.length - 1] - data[0];
-        const labelArray = this.buildLabelArray(data_ready, data);
-        const lg = svg
-            .append('g')
-            .attr('class', 'label')
-            .attr('transform', this.centerTranslation(radius));
+            .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);
+        });
+        labelArray = labelArrayTemp;
         lg.selectAll('.bubble')
             .data(labelArray)
             .enter()
             .append('g')
-            .attr('transform', (d) => {
-            const newAngle = self.chartConfiguration.minAngle + (d.value / range) * 180;
-            return `rotate(${newAngle}) translate(0,${self.chartConfiguration.labelInset - radius - 20})`;
+            .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('fill', 'var(--chart-text-color)')
-            .style('font-size', window.innerWidth < 1400 ? '12px' : '14px')
-            .style('font-weight', '600')
-            .text((d) => (metaData.dataType ? d.name + metaData.dataType : d.name));
-    }
-    buildLabelArray(data_ready, data) {
-        const labelArray = [{ name: data[0], value: 0 }];
-        let count = 0;
-        data_ready.forEach((unit, i) => {
-            count += unit;
-            labelArray.push({ name: data[i + 1], value: count });
+            .text(function (d) {
+            if (metaData.dataType) {
+                return d.name + metaData.dataType;
+            }
+            return d.name;
         });
-        return labelArray;
-    }
-    drawCenterTexts(svg, radius, metaData) {
-        const self = this;
-        const top = radius / 2 - 10;
-        const mid = top + self.chartConfiguration.currentValueHeightScaleFactor;
-        const bottom = mid + self.chartConfiguration.currentValueHeightScaleFactor;
-        // current value
         svg
             .append('foreignObject')
-            .attr('transform', `translate(${radius - this.chartConfiguration.currentValueWidthScaleFactor / 2},${top})`)
+            .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);
-        // status
         if (metaData.status) {
-            const widthTemp = metaData.status.length > 4 ? 210 : 120;
+            let widthTemp = metaData.status.length > 4 ? 210 : 120;
             svg
                 .append('foreignObject')
-                .attr('transform', `translate(${radius - widthTemp / 2},${mid})`)
+                .attr('transform', 'translate(' + (radius - widthTemp / 2) + ',' + midTextPosition + ')')
                 .attr('width', widthTemp)
+                .attr('height', this.chartConfiguration.currentValueHeightScaleFactor + 10)
                 .append('xhtml:div')
                 .attr('class', 'status-display')
+                .style('font-size', this.chartConfiguration.currentValueHeightScaleFactor - 25 + 'px')
                 .html(metaData.status);
         }
-        // date range
         svg
             .append('foreignObject')
-            .attr('transform', `translate(${radius - 105},${bottom})`)
+            .attr('transform', 'translate(' + (radius - 105) + ',' + bottomTextPosition + ')')
             .attr('width', 210)
+            .attr('height', this.chartConfiguration.currentValueHeightScaleFactor)
             .append('xhtml:div')
             .attr('class', 'daterange-display')
-            .html(metaData.dateRange
-            ? `<span class="marginright-3"><i class="fa fa-calendar"></i></span><span>${metaData.dateRange}</span>`
-            : '');
-    }
-    centerTranslation(radius) {
-        return `translate(${radius},${radius})`;
-    }
-    centerSvg(svg, chartContainer, width, height) {
-        const margin = this.chartConfiguration.margin;
-        const containerMidWidth = parseInt(chartContainer.style('width')) / 2;
-        const nodeHalfWidth = svg.node().getBoundingClientRect().width / 2;
-        const updatedStartingPoint = containerMidWidth - nodeHalfWidth;
-        svg.attr('transform', `translate(${updatedStartingPoint + margin.left},${margin.top})`);
-    }
-    /** -------------------------------
-     *  Event Handlers
-     *  ------------------------------*/
+            .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 +
+            ')');
+    }
     handleClick(d) {
         this.clickEvent.emit(d);
     }