axidio-styleguide-library1-v2 0.2.24 → 0.2.25

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

@@ -6640,15 +6640,18 @@ class HorizontalBarsWithScrollZoomComponent extends ComponentUniqueId {
         this.isTransparentBackground = false;
         this.isCC = false;
         this.isZoomedOut = true;
-        this.TICK_LENGTHS = {
-            short: 4,
-            long: 16,
-            shortBg: 5,
-            longBg: 30,
-        };
-        this.SPACING = {
-            rightSvgWidth: 60,
-            leftAndRight: 50,
+        this.CONSTANTS = {
+            RIGHT_SVG_WIDTH: 60,
+            LEFT_RIGHT_SPACES: 50,
+            SHORT_TICK_LENGTH: 4,
+            LONG_TICK_LENGTH: 16,
+            SHORT_TICK_LENGTH_BG: 5,
+            LONG_TICK_LENGTH_BG: 30,
+            MIN_MOBILE_BAR_WIDTH: 32,
+            DESKTOP_MIN_BAR_WIDTH: 40,
+            MOBILE_BAR_PADDING: 12,
+            ZOOM_THRESHOLD: 30,
+            ZOOM_IN_THRESHOLD: 8,
         };
         this.defaultConfiguration = {
             margin: { top: 20, right: 20, bottom: 20, left: 40 },
@@ -6665,24 +6668,54 @@ class HorizontalBarsWithScrollZoomComponent extends ComponentUniqueId {
             forComparison: true,
             headerMenuOptions: HeaderConfigHelper.headerConfig.headerMenuOptions,
             yAxisGrid: false,
+            // Optional configs with undefined defaults
+            isHeaderVisible: undefined,
+            isTransparentBackground: undefined,
+            isTopCaptionVisible: undefined,
+            isMultiChartGridLine: undefined,
+            isFullScreen: undefined,
+            customYscale: undefined,
+            isXaxisLabelHidden: undefined,
+            isYaxisLabelHidden: undefined,
+            isYaxisHidden: undefined,
+            isYaxisDashed: undefined,
+            isXaxisColor: undefined,
+            textFormatter: undefined,
+            showTotalOnTop: undefined,
+            backendFormatterHasPriority: undefined,
+            showAngledLabels: undefined,
+            isNoAlternateXaxisText: undefined,
+            isXgridBetweenLabels: undefined,
+            showXaxisTop: undefined,
+            xAxisGrid: undefined,
+            xLabelsOnSameLine: undefined,
+            hideXaxisTick: undefined,
+            isDrilldownChart: undefined,
+            isTargetLine: undefined,
+            displayTitleOnTop: undefined,
+            isToggleVisible: undefined,
+            isTitleHidden: undefined,
         };
     }
     ngOnInit() { }
-    ngOnChanges(changes) {
-        this.redrawChart();
+    ngOnChanges() {
+        this.removeExistingChart();
+        this.initializeStackedChart();
     }
     onResized(event) {
-        setTimeout(() => this.redrawChart(), 10);
+        setTimeout(() => {
+            this.removeExistingChart();
+            this.initializeStackedChart();
+        }, 10);
     }
     isZoomOutSelected(isZoomOut) {
         this.isZoomedOut = isZoomOut;
-        this.redrawChart();
+        this.ngOnChanges();
     }
-    redrawChart() {
+    removeExistingChart() {
         d3.select('#' + this.uniqueId).remove();
-        this.initializeStackedChart();
     }
-    getDeviceBreakpoints() {
+    getDeviceConfig() {
         const width = window.innerWidth;
         return {
             isMobile: width < 576,
@@ -6690,7 +6723,7 @@ class HorizontalBarsWithScrollZoomComponent extends ComponentUniqueId {
             isDesktop: width >= 992,
         };
     }
-    applyResponsiveConfig(device) {
+    configureResponsiveSettings(device) {
         if (device.isMobile) {
             this.chartConfiguration.margin = { top: 20, right: 10, bottom: 40, left: 30 };
             this.chartConfiguration.numberOfYTicks = 4;
@@ -6708,9 +6741,9 @@ class HorizontalBarsWithScrollZoomComponent extends ComponentUniqueId {
         }
     }
     mergeConfigurations() {
-        Object.keys(this.defaultConfiguration).forEach((key) => {
+        for (const key in this.defaultConfiguration) {
             this.chartConfiguration[key] = ChartHelper.getValueByConfigurationType(key, this.defaultConfiguration, this.customChartConfiguration);
-        });
+        }
     }
     prepareMetaData(metaData) {
         if (!metaData.unit)
@@ -6725,183 +6758,70 @@ class HorizontalBarsWithScrollZoomComponent extends ComponentUniqueId {
         }
         return metaData;
     }
-    parseTargetValue(targetLineData) {
-        if (!targetLineData?.target)
-            return null;
-        const parsedNum = parseFloat(String(targetLineData.target));
-        if (isNaN(parsedNum))
-            return null;
-        return Number.isInteger(parsedNum)
-            ? parseInt(String(targetLineData.target))
-            : parsedNum;
-    }
-    calculateDimensions(containerWidth, containerHeight, margin, device) {
+    calculateDimensions(chartContainer, verticalContainer, margin, device, dataLength) {
+        const containerWidth = chartContainer.node().getBoundingClientRect().width;
+        const containerHeight = verticalContainer.node().getBoundingClientRect().height;
         let width = containerWidth - margin.left - margin.right;
         let height = containerHeight * (this.chartConfiguration.svgHeight / 100) - margin.top - margin.bottom;
-        // Adjust width for zoom levels
-        const dataLength = this.chartData.data.length;
-        if (dataLength > 30 && this.isZoomedOut) {
+        // Handle zoom out scenario
+        if (dataLength > this.CONSTANTS.ZOOM_THRESHOLD && this.isZoomedOut) {
             const minWidth = dataLength * (device.isMobile ? 15 : 25);
             width = Math.max(width, minWidth);
         }
-        if (dataLength > 8 && !this.isZoomedOut) {
+        // Handle zoom in scenario
+        if (dataLength > this.CONSTANTS.ZOOM_IN_THRESHOLD && !this.isZoomedOut) {
             width = dataLength * (device.isMobile ? 60 : 130);
         }
-        // Apply special height configurations
-        if (this.chartConfiguration.isFullScreen && this.chartConfiguration.svgHeight !== 80) {
-            height = this.chartConfiguration.svgHeight;
-        }
-        else if (this.chartConfiguration.isFullScreen) {
-            height = containerHeight;
+        // Handle full screen
+        if (this.chartConfiguration.isFullScreen) {
+            height = this.chartConfiguration.svgHeight !== 80
+                ? this.chartConfiguration.svgHeight
+                : containerHeight;
         }
+        // Handle drilldown
         if (this.chartConfiguration.isDrilldownChart) {
             height = containerHeight - margin.top - margin.bottom - (device.isMobile ? 60 : 130);
         }
-        return { width, height };
-    }
-    calculateBarDimensions(width, dataLength, device) {
+        // Calculate bar dimensions
         let barWidth;
         let barPadding;
         let requiredSvgWidth;
         if (device.isMobile) {
-            const minBarWidth = 32;
-            barWidth = minBarWidth;
-            barPadding = 12;
-            requiredSvgWidth = Math.max(width - this.SPACING.rightSvgWidth, (barWidth + barPadding) * dataLength + this.SPACING.leftAndRight * 2 +
-                this.SPACING.rightSvgWidth - barPadding);
+            barWidth = this.CONSTANTS.MIN_MOBILE_BAR_WIDTH;
+            barPadding = this.CONSTANTS.MOBILE_BAR_PADDING;
+            requiredSvgWidth = Math.max(width - this.CONSTANTS.RIGHT_SVG_WIDTH, (barWidth + barPadding) * dataLength + this.CONSTANTS.LEFT_RIGHT_SPACES * 2 +
+                this.CONSTANTS.RIGHT_SVG_WIDTH - barPadding);
         }
         else {
-            barWidth = Math.max(40, (width - this.SPACING.rightSvgWidth - this.SPACING.leftAndRight * 2) / dataLength);
+            barWidth = Math.max(this.CONSTANTS.DESKTOP_MIN_BAR_WIDTH, (width - this.CONSTANTS.RIGHT_SVG_WIDTH - this.CONSTANTS.LEFT_RIGHT_SPACES * 2) / dataLength);
             barPadding = 0;
-            requiredSvgWidth = width - this.SPACING.rightSvgWidth;
-        }
-        return { barWidth, barPadding, requiredSvgWidth };
-    }
-    createScales(data, height, width, device) {
-        const xScale = d3
-            .scaleBand()
-            .rangeRound([
-            this.SPACING.leftAndRight,
-            width - this.SPACING.rightSvgWidth - this.SPACING.leftAndRight
-        ])
-            .domain(data.map(d => d.name).reverse())
-            .padding(device.isMobile ? 0.2 : 0.5);
-        const yScale = d3.scaleLinear().rangeRound([height, 0]);
-        return { xScale, yScale };
-    }
-    calculateYScaleDomain(layers, targetValue) {
-        let maxValue = d3.max(layers, (d) => d3.max(d, (d) => d[1])) || 0;
-        if (maxValue === 0) {
-            maxValue = targetValue ? targetValue + 20 : 100;
-        }
-        if (this.chartConfiguration.customYscale) {
-            maxValue *= this.chartConfiguration.customYscale;
-        }
-        if (targetValue && maxValue < targetValue) {
-            maxValue = maxValue < 10 && targetValue < 10
-                ? targetValue + 3
-                : targetValue + 20;
-        }
-        return maxValue;
-    }
-    shouldShowTargetLineColor(d, targetValue) {
-        return !!(!isNaN(d[0]) &&
-            !isNaN(d[1]) &&
-            this.chartData.targetLineData &&
-            targetValue &&
-            parseFloat(d[1]) - parseFloat(d[0]) >= targetValue);
-    }
-    getBarFillColor(d, key, metaData, targetValue) {
-        if (this.shouldShowTargetLineColor(d, targetValue)) {
-            return this.chartData.targetLineData?.barAboveTargetColor || metaData.colors[key];
+            requiredSvgWidth = width - this.CONSTANTS.RIGHT_SVG_WIDTH;
         }
-        return metaData.colors[key];
-    }
-    isAcronym(label) {
-        const alphaOnly = label.replace(/[^A-Za-z]/g, '');
-        return (label.length <= 4 && /^[A-Z]+$/.test(label)) ||
-            (label === label.toUpperCase() && /[A-Z]/.test(label));
-    }
-    formatAxisLabel(text) {
-        const isAcr = this.isAcronym(text);
         return {
-            formatted: isAcr ? text.toUpperCase() : text.toLowerCase(),
-            isAcronym: isAcr
+            width,
+            height,
+            containerWidth,
+            containerHeight,
+            barWidth,
+            barPadding,
+            requiredSvgWidth,
         };
     }
-    initializeStackedChart() {
-        const device = this.getDeviceBreakpoints();
-        this.applyResponsiveConfig(device);
-        this.mergeConfigurations();
-        const { data, metaData, lineData } = this.chartData;
-        const preparedMetaData = this.prepareMetaData(metaData);
-        const targetValue = this.parseTargetValue(this.chartData.targetLineData);
-        const chartContainer = d3.select(this.containerElt.nativeElement);
-        const verticalstackedcontainer = d3.select(this.verticalstackedcontainerElt.nativeElement);
-        const margin = this.chartConfiguration.margin;
-        const containerWidth = chartContainer.node().getBoundingClientRect().width;
-        const containerHeight = verticalstackedcontainer.node().getBoundingClientRect().height;
-        const { width, height } = this.calculateDimensions(containerWidth, containerHeight, margin, device);
-        // Apply visibility configurations
-        if (this.chartConfiguration.isHeaderVisible !== undefined) {
-            this.isHeaderVisible = this.chartConfiguration.isHeaderVisible;
-        }
-        if (this.chartConfiguration.isTopCaptionVisible !== undefined) {
-            this.isTopCaptionVisible = this.chartConfiguration.isTopCaptionVisible;
-        }
-        if (this.chartConfiguration.isTransparentBackground !== undefined) {
-            this.isTransparentBackground = this.chartConfiguration.isTransparentBackground;
-        }
-        // Create formatters
-        const formatFromBackend = this.chartConfiguration.textFormatter
-            ? ChartHelper.dataValueFormatter(this.chartConfiguration.textFormatter)
-            : null;
-        const formatForHugeNumbers = ChartHelper.dataValueFormatter('.2s');
-        // Create SVG containers
-        const { barWidth, barPadding, requiredSvgWidth } = this.calculateBarDimensions(width, data.length, device);
-        const outerContainer = this.createOuterContainer(chartContainer, height, margin);
-        const { svgYAxisLeft, svgYAxisRight } = this.createAxisContainers(outerContainer, height, margin);
-        const { innerContainer, svg } = this.createInnerContainer(outerContainer, requiredSvgWidth, height, margin, device);
-        // Create scales
-        const { xScale, yScale } = this.createScales(data, height, width, device);
-        // Stack data
-        const stack = d3
-            .stack()
-            .keys(preparedMetaData.keyList)
-            .offset(d3.stackOffsetNone);
-        const layers = stack(data);
-        // Set Y scale domain
-        const maxValue = this.calculateYScaleDomain(layers, targetValue || undefined);
-        yScale.domain([0, maxValue]).nice();
-        // Render chart elements
-        this.renderGrids(svg, xScale, yScale, height, width);
-        this.renderBars(svg, layers, xScale, yScale, preparedMetaData, device, barWidth, barPadding, targetValue, formatFromBackend, formatForHugeNumbers);
-        this.renderAxes(svg, svgYAxisLeft, svgYAxisRight, xScale, yScale, data, height, width, device);
-        this.renderLabels(svg, svgYAxisLeft, preparedMetaData, height, width, margin);
-        if (this.chartData.targetLineData && targetValue) {
-            this.renderTargetLine(svg, svgYAxisRight, yScale, width, targetValue, preparedMetaData);
-        }
-        if (lineData) {
-            this.renderLineChart(svg, lineData, xScale, height, preparedMetaData.colors);
-        }
-    }
-    createOuterContainer(chartContainer, height, margin) {
-        return chartContainer
+    createSvgContainers(chartContainer, dimensions, margin) {
+        const outerContainer = chartContainer
             .append('div')
             .attr('id', this.uniqueId)
             .attr('class', 'outer-container')
             .style('width', '100%')
-            .style('height', height)
+            .style('height', dimensions.height)
             .style('overflow-x', 'hidden')
             .style('padding-left', `${margin.left}px`)
             .style('margin-left', '10px')
-            .style('padding-right', `${this.SPACING.rightSvgWidth}px`);
-    }
-    createAxisContainers(outerContainer, height, margin) {
+            .style('padding-right', `${this.CONSTANTS.RIGHT_SVG_WIDTH}px`);
         const svgYAxisLeft = outerContainer
             .append('svg')
             .attr('width', '80')
-            .attr('height', height + margin.top + margin.bottom)
+            .attr('height', dimensions.height + margin.top + margin.bottom)
             .style('position', 'absolute')
             .style('left', '0')
             .style('z-index', 1)
@@ -6909,65 +6829,85 @@ class HorizontalBarsWithScrollZoomComponent extends ComponentUniqueId {
             .attr('transform', `translate(${margin.left + 10},${margin.top})`);
         const svgYAxisRight = outerContainer
             .append('svg')
-            .attr('width', this.SPACING.rightSvgWidth)
-            .attr('height', height + margin.top + margin.bottom)
+            .attr('width', this.CONSTANTS.RIGHT_SVG_WIDTH)
+            .attr('height', dimensions.height + margin.top + margin.bottom)
             .style('position', 'absolute')
             .style('right', '2px')
             .style('z-index', 1)
             .append('g')
             .attr('transform', `translate(0,${margin.top})`);
-        return { svgYAxisLeft, svgYAxisRight };
-    }
-    createInnerContainer(outerContainer, requiredSvgWidth, height, margin, device) {
         const innerContainer = outerContainer
             .append('div')
             .attr('class', 'inner-container')
             .style('width', '100%')
-            .style('overflow-x', device.isMobile ? 'auto' : 'auto');
+            .style('overflow-x', 'auto');
         const svg = innerContainer
             .append('svg')
-            .attr('width', requiredSvgWidth)
-            .attr('height', height + margin.top + margin.bottom + 30)
+            .attr('width', dimensions.requiredSvgWidth)
+            .attr('height', dimensions.height + margin.top + margin.bottom + 30)
             .append('g')
             .attr('transform', `translate(0,${margin.top})`);
-        return { innerContainer, svg };
+        return { svg, svgYAxisLeft, svgYAxisRight, innerContainer };
     }
-    renderGrids(svg, xScale, yScale, height, width) {
-        if (this.chartConfiguration.isXgridBetweenLabels) {
-            svg
-                .append('g')
-                .attr('class', 'grid')
-                .attr('transform', `translate(${xScale.bandwidth() / 2},${height})`)
-                .call(d3.axisBottom(xScale).tickSize(-height).tickFormat(''))
-                .style('stroke-dasharray', '5 5')
-                .style('color', '#999999')
-                .call((g) => g.select('.domain').remove());
+    createScales(data, layers, lineData, dimensions, device) {
+        const { width, height, barWidth, barPadding } = dimensions;
+        const xScale = d3
+            .scaleBand()
+            .rangeRound([
+            this.CONSTANTS.LEFT_RIGHT_SPACES,
+            width - this.CONSTANTS.RIGHT_SVG_WIDTH - this.CONSTANTS.LEFT_RIGHT_SPACES
+        ])
+            .domain(data.map(d => d.name).reverse())
+            .padding(device.isMobile ? 0.2 : 0.5);
+        const xScaleFromOrigin = d3
+            .scaleBand()
+            .rangeRound([width - this.CONSTANTS.RIGHT_SVG_WIDTH, 0])
+            .domain(data.map(d => d.name).reverse());
+        const yScale = d3.scaleLinear().rangeRound([height, 0]);
+        let maxValue = d3.max(layers, (d) => d3.max(d, (d) => d[1]));
+        if (maxValue === 0) {
+            maxValue = this.chartData.targetLineData
+                ? Number(this.chartData.targetLineData.target) + 20
+                : 100;
         }
-        if (this.chartConfiguration.yAxisGrid) {
-            svg
-                .append('g')
-                .attr('class', 'grid')
-                .call(d3
-                .axisLeft(yScale)
-                .ticks(this.chartConfiguration.numberOfYTicks)
-                .tickSize(-width)
-                .tickFormat(''))
-                .style('color', 'var(--chart-grid-color)')
-                .style('opacity', '1');
+        if (this.chartConfiguration.customYscale) {
+            maxValue *= this.chartConfiguration.customYscale;
         }
-        if (this.chartConfiguration.xAxisGrid) {
-            this.chartConfiguration.xAxisGrid.forEach((gridPos, index) => {
-                svg
-                    .append('g')
-                    .attr('class', `x${index + 2} axis${index + 2}`)
-                    .style('color', 'var(--chart-grid-color)')
-                    .attr('transform', `translate(0,${height * gridPos})`)
-                    .call(d3.axisBottom(xScale).tickSize(0).ticks(5).tickFormat(''))
-                    .style('fill', 'var(--chart-text-color)');
-            });
+        if (this.chartData.targetLineData && maxValue < Number(this.chartData.targetLineData.target)) {
+            const target = Number(this.chartData.targetLineData.target);
+            maxValue = maxValue < 10 && target < 10 ? target + 3 : target + 20;
+        }
+        yScale.domain([0, maxValue]).nice();
+        let lineYscale = null;
+        if (lineData) {
+            lineYscale = d3
+                .scaleLinear()
+                .domain([0, d3.max(lineData, d => +d.value)])
+                .range([height, 0]);
+        }
+        return { xScale, xScaleFromOrigin, yScale, lineYscale };
+    }
+    createAxes(scales) {
+        const xAxis = d3
+            .axisBottom(scales.xScale)
+            .tickSize(0)
+            .tickFormat(this.chartConfiguration.xAxisLabelFomatter);
+        const yAxis = d3
+            .axisLeft(scales.yScale)
+            .ticks(this.chartConfiguration.numberOfYTicks)
+            .tickSize(0)
+            .tickFormat(this.chartConfiguration.yAxisLabelFomatter);
+        let yLineAxis = null;
+        if (scales.lineYscale) {
+            yLineAxis = d3
+                .axisRight(scales.lineYscale)
+                .ticks(this.chartConfiguration.numberOfYTicks)
+                .tickSize(0)
+                .tickFormat(this.chartConfiguration.yLineAxisLabelFomatter);
         }
+        return { xAxis, yAxis, yLineAxis };
     }
-    renderBars(svg, layers, xScale, yScale, metaData, device, barWidth, barPadding, targetValue, formatFromBackend, formatForHugeNumbers) {
+    renderBars(svg, layers, scales, metaData, dimensions, device) {
         const layer = svg
             .selectAll('.layer')
             .data(layers)
@@ -6975,7 +6915,17 @@ class HorizontalBarsWithScrollZoomComponent extends ComponentUniqueId {
             .append('g')
             .attr('class', 'layer')
             .style('fill', (d) => metaData.colors[d.key]);
-        const rect = layer.selectAll('rect').data((d) => d).enter();
+        const rect = layer
+            .selectAll('rect')
+            .data((d) => d)
+            .enter();
+        this.appendRectangles(rect, scales, metaData, dimensions, device);
+        this.addInteractions(rect, svg, metaData, scales);
+        return rect;
+    }
+    appendRectangles(rect, scales, metaData, dimensions, device) {
+        const { barWidth, barPadding } = dimensions;
+        const { xScale, yScale } = scales;
         rect
             .append('rect')
             .on('click', (d) => {
@@ -6994,9 +6944,9 @@ class HorizontalBarsWithScrollZoomComponent extends ComponentUniqueId {
         })
             .attr('x', (d, i) => {
             if (device.isMobile) {
-                return this.SPACING.leftAndRight + i * (barWidth + barPadding);
+                return this.CONSTANTS.LEFT_RIGHT_SPACES + i * (barWidth + barPadding);
             }
-            if (this.chartConfiguration.isMultiChartGridLine === undefined) {
+            if (!this.chartConfiguration.isMultiChartGridLine) {
                 return xScale(d.data.name);
             }
             if (this.chartConfiguration.isDrilldownChart && this.chartData.data.length <= 3) {
@@ -7014,99 +6964,307 @@ class HorizontalBarsWithScrollZoomComponent extends ComponentUniqueId {
             .attr('width', (d) => {
             if (device.isMobile)
                 return barWidth;
-            if (this.chartConfiguration.isMultiChartGridLine === undefined) {
+            if (!this.chartConfiguration.isMultiChartGridLine)
                 return xScale.bandwidth();
+            if (this.chartConfiguration.isDrilldownChart && this.chartData.data.length <= 3) {
+                return 70;
             }
-            return this.chartConfiguration.isDrilldownChart && this.chartData.data.length <= 3
-                ? 70
-                : xScale.bandwidth() * 0.8;
+            return xScale.bandwidth() * 0.8;
         })
             .style('cursor', (d) => {
-            if (!metaData.hasDrillDown)
-                return 'default';
-            if (metaData.barWithoutClick?.includes(d.data.name.toLowerCase())) {
-                return 'default';
+            if (metaData.hasDrillDown) {
+                if (metaData.barWithoutClick?.includes(d.data.name.toLowerCase())) {
+                    return 'default';
+                }
+                return 'pointer';
             }
-            return 'pointer';
+            return 'default';
         })
-            .style('fill', (d) => this.getBarFillColor(d, d.key, metaData, targetValue || undefined));
-        // Add tooltips and labels
-        if (!this.isCC && !this.chartConfiguration.isMultiChartGridLine) {
-            rect.append('svg:title').text((d) => d[1] - d[0]);
+            .style('fill', (d) => this.getBarColor(d, metaData));
+    }
+    getBarColor(d, metaData) {
+        if (!isNaN(d[0]) &&
+            !isNaN(d[1]) &&
+            this.chartData.targetLineData &&
+            parseFloat(d[1]) - parseFloat(d[0]) >= parseFloat(String(this.chartData.targetLineData.target))) {
+            return this.chartData.targetLineData.barAboveTargetColor || metaData.colors[d.key];
         }
-        this.addBarLabels(rect, xScale, yScale, metaData, formatFromBackend, formatForHugeNumbers);
+        return metaData.colors[d.key];
     }
-    addBarLabels(rect, xScale, yScale, metaData, formatFromBackend, formatForHugeNumbers) {
-        if (this.chartConfiguration.showTotalOnTop) {
-            rect
-                .append('text')
-                .attr('x', (d) => xScale(d.data.name) + xScale.bandwidth() / 2)
-                .attr('class', 'lib-verticalstack-labels-ontop-weklycharts')
-                .attr('y', (d) => yScale(d[1]) - 3)
-                .text((d) => {
-                if (!isNaN(d[1] - d[0]) && d[1] - d[0] !== 0) {
-                    const value = d[1] - d[0];
-                    const formatter = value <= 999 ? formatFromBackend : formatForHugeNumbers;
-                    return metaData.unit ? metaData.unit + formatter(value) : formatter(value);
-                }
-            });
+    addInteractions(rect, svg, metaData, scales) {
+        rect
+            .selectAll('rect')
+            .on('mouseenter', (d) => this.handleMouseOver(d, svg, metaData, scales))
+            .on('mouseout', (d) => this.handleMouseOut(svg, metaData));
+    }
+    handleMouseOver(d, svg, metaData, scales) {
+        if (!this.chartConfiguration.displayTitleOnTop)
+            return;
+        svg.selectAll('rect')
+            .filter((data) => data === d)
+            .style('fill', (d) => this.getHoverColor(d, metaData));
+        this.displayTooltip(d, svg, metaData, scales);
+    }
+    getHoverColor(d, metaData) {
+        if (!isNaN(d[0]) &&
+            !isNaN(d[1]) &&
+            this.chartData.targetLineData &&
+            parseFloat(d[1]) - parseFloat(d[0]) >= parseFloat(String(this.chartData.targetLineData.target))) {
+            return this.chartData.targetLineData.barAboveTargetHoverColor ||
+                this.chartData.targetLineData.barAboveTargetColor ||
+                metaData.colors[d.key];
         }
+        return metaData.hoverColor || metaData.colors[d.key];
     }
-    renderAxes(svg, svgYAxisLeft, svgYAxisRight, xScale, yScale, data, height, width, device) {
-        const xAxis = d3
-            .axisBottom(xScale)
-            .tickSize(0)
-            .tickFormat(this.chartConfiguration.xAxisLabelFomatter);
-        const yAxis = d3
-            .axisLeft(yScale)
-            .ticks(this.chartConfiguration.numberOfYTicks)
-            .tickSize(0)
-            .tickFormat(this.chartConfiguration.yAxisLabelFomatter);
-        // Render based on chart type
-        if (this.chartConfiguration.isMultiChartGridLine === undefined) {
-            this.renderStandardAxes(svg, xAxis, yAxis, data, height, device);
+    displayTooltip(d, svg, metaData, scales) {
+        const { xScale, yScale } = scales;
+        const value = d[1] - d[0];
+        if (isNaN(value))
+            return;
+        const width = /week/i.test(d.data.name) && /\d{4}-\d{2}-\d{2}/.test(d.data.name)
+            ? '250px'
+            : xScale.bandwidth() + this.CONSTANTS.LEFT_RIGHT_SPACES * 2 > 180
+                ? '180px'
+                : xScale.bandwidth() + this.CONSTANTS.LEFT_RIGHT_SPACES * 2;
+        svg
+            .append('foreignObject')
+            .attr('x', this.calculateTooltipX(d, xScale, width))
+            .attr('class', 'lib-verticalstack-title-ontop')
+            .attr('y', yScale(d[1]) - 51)
+            .attr('width', width)
+            .attr('height', 40)
+            .append('xhtml:div')
+            .attr('class', 'title')
+            .style('z-index', 99)
+            .html(this.generateTooltipHtml(d, metaData, value));
+    }
+    calculateTooltipX(d, xScale, width) {
+        const bandwidth = xScale.bandwidth();
+        const numericWidth = typeof width === 'string' ? parseInt(width) : width;
+        if (bandwidth + this.CONSTANTS.LEFT_RIGHT_SPACES * 2 > 180) {
+            return xScale(d.data.name) - this.CONSTANTS.LEFT_RIGHT_SPACES +
+                (bandwidth + this.CONSTANTS.LEFT_RIGHT_SPACES * 2 - 180) / 2;
+        }
+        return xScale(d.data.name) - this.CONSTANTS.LEFT_RIGHT_SPACES;
+    }
+    generateTooltipHtml(d, metaData, value) {
+        if (value === 0)
+            return '<span class="title-top-text">0</span>';
+        const dataType = metaData.dataType || '';
+        const name = d.data.name ? `<span class="title-bar-name">${d.data.name}</span>` : '';
+        const valueText = metaData.unit
+            ? `${metaData.unit}${value} ${dataType}`
+            : `${value} ${dataType}`;
+        return `${name}<span class="title-top-text">${valueText}</span>`;
+    }
+    handleMouseOut(svg, metaData) {
+        if (!this.chartConfiguration.displayTitleOnTop)
+            return;
+        svg.selectAll('rect')
+            .style('fill', (d) => this.getBarColor(d, metaData));
+        svg.selectAll('.lib-verticalstack-title-ontop').remove();
+    }
+    renderAxisLabels(svg, svgYAxisLeft, metaData, dimensions, margin) {
+        if (metaData.yLabel) {
+            this.addYAxisLabel(svgYAxisLeft, metaData.yLabel, dimensions.height, margin);
+        }
+        if (metaData.xLabel) {
+            this.addXAxisLabel(svg, metaData.xLabel, dimensions.width, dimensions.height, margin);
+        }
+    }
+    addYAxisLabel(svgYAxisLeft, label, height, margin) {
+        const isria = this.customChartConfiguration?.isRia;
+        const isAcronym = this.isAcronymLabel(label);
+        const yPosition = isria ? -margin.left / 2 - 30 : -margin.left / 2 - 40;
+        svgYAxisLeft.selectAll('.lib-axis-group-label, .lib-ylabel-drilldowncharts, .lib-ylabel-weeklyCharts').remove();
+        svgYAxisLeft
+            .append('text')
+            .attr('class', this.getYAxisLabelClass())
+            .attr('style', this.chartConfiguration.yAxisCustomlabelStyles)
+            .attr('transform', 'rotate(-90)')
+            .attr('y', yPosition)
+            .attr('x', -height / 2)
+            .attr('dy', '1em')
+            .style('text-anchor', 'middle')
+            .style('fill', 'var(--chart-text-color)')
+            .text(isAcronym ? label.toUpperCase() : label.toLowerCase())
+            .style('text-transform', isAcronym ? 'none' : 'capitalize');
+    }
+    addXAxisLabel(svg, label, width, height, margin) {
+        const isria = this.customChartConfiguration?.isRia;
+        const isAcronym = this.isAcronymLabel(label);
+        const xPosition = isria
+            ? height + margin.top + margin.bottom
+            : height + margin.top + margin.bottom + 10;
+        svg
+            .append('text')
+            .attr('class', this.getXAxisLabelClass())
+            .attr('style', this.chartConfiguration.xAxisCustomlabelStyles)
+            .attr('transform', `translate(${width / 2},${xPosition})`)
+            .style('text-anchor', 'middle')
+            .style('fill', 'var(--chart-text-color)')
+            .text(isAcronym ? label.toUpperCase() : label.toLowerCase())
+            .style('text-transform', isAcronym ? 'none' : 'capitalize');
+    }
+    isAcronymLabel(label) {
+        const cleanLabel = label.replace(/[^A-Za-z]/g, '');
+        return (label.length <= 4 && /^[A-Z]+$/.test(label)) ||
+            (label === label.toUpperCase() && /[A-Z]/.test(label));
+    }
+    getYAxisLabelClass() {
+        let baseClass = 'lib-axis-group-label font-size-1';
+        if (this.chartConfiguration.isDrilldownChart) {
+            return `${baseClass} lib-ylabel-drilldowncharts`;
+        }
+        if (this.chartConfiguration.isMultiChartGridLine !== undefined) {
+            return `${baseClass} lib-ylabel-weeklyCharts`;
+        }
+        return `${baseClass} lib-axis-waterfall-label`;
+    }
+    getXAxisLabelClass() {
+        let baseClass = 'lib-axis-group-label font-size-1';
+        if (this.chartConfiguration.isDrilldownChart) {
+            return `${baseClass} lib-xlabel-drilldowncharts`;
+        }
+        if (this.chartConfiguration.isMultiChartGridLine !== undefined) {
+            return `${baseClass} lib-xlabel-weeklyCharts`;
+        }
+        return `${baseClass} lib-axis-waterfall-label`;
+    }
+    applyConfigurationFlags() {
+        if (this.chartConfiguration.isHeaderVisible !== undefined) {
+            this.isHeaderVisible = this.chartConfiguration.isHeaderVisible;
+        }
+        if (this.chartConfiguration.isTopCaptionVisible !== undefined) {
+            this.isTopCaptionVisible = this.chartConfiguration.isTopCaptionVisible;
+        }
+        if (this.chartConfiguration.isTransparentBackground !== undefined) {
+            this.isTransparentBackground = this.chartConfiguration.isTransparentBackground;
+        }
+    }
+    initializeStackedChart() {
+        const device = this.getDeviceConfig();
+        this.configureResponsiveSettings(device);
+        this.mergeConfigurations();
+        this.applyConfigurationFlags();
+        const data = this.chartData.data;
+        const metaData = this.prepareMetaData(this.chartData.metaData);
+        const lineData = this.chartData.lineData;
+        const colors = metaData.colors;
+        const keyList = metaData.keyList;
+        const chartContainer = d3.select(this.containerElt.nativeElement);
+        const verticalstackedcontainer = d3.select(this.verticalstackedcontainerElt.nativeElement);
+        const margin = this.chartConfiguration.margin;
+        const dimensions = this.calculateDimensions(chartContainer, verticalstackedcontainer, margin, device, data.length);
+        const { svg, svgYAxisLeft, svgYAxisRight } = this.createSvgContainers(chartContainer, dimensions, margin);
+        // Create stack and layers
+        const stack = d3.stack().keys(keyList).offset(d3.stackOffsetNone);
+        const layers = stack(data);
+        data.sort((a, b) => b.total - a.total);
+        const scales = this.createScales(data, layers, lineData, dimensions, device);
+        const axes = this.createAxes(scales);
+        // Render chart elements
+        this.renderGrids(svg, scales, dimensions);
+        const rect = this.renderBars(svg, layers, scales, metaData, dimensions, device);
+        this.renderAxes(svg, svgYAxisLeft, svgYAxisRight, axes, scales, dimensions, device, data);
+        this.renderAxisLabels(svg, svgYAxisLeft, metaData, dimensions, margin);
+        this.renderTargetLine(svg, svgYAxisRight, scales, dimensions, metaData);
+        this.renderDataLabels(rect, scales, metaData, dimensions);
+        this.renderLineChart(svg, lineData, scales, colors, metaData);
+    }
+    renderGrids(svg, scales, dimensions) {
+        if (this.chartConfiguration.isXgridBetweenLabels) {
+            svg
+                .append('g')
+                .attr('class', 'grid')
+                .attr('transform', `translate(${scales.xScale.bandwidth() / 2},${dimensions.height})`)
+                .call(d3.axisBottom(scales.xScale).tickSize(-dimensions.height).tickFormat(''))
+                .style('stroke-dasharray', '5 5')
+                .style('color', '#999999')
+                .call((g) => g.select('.domain').remove());
+        }
+        if (this.chartConfiguration.yAxisGrid) {
+            svg
+                .append('g')
+                .attr('class', 'grid')
+                .call(d3
+                .axisLeft(scales.yScale)
+                .ticks(this.chartConfiguration.numberOfYTicks)
+                .tickSize(-dimensions.width)
+                .tickFormat(''))
+                .style('color', 'var(--chart-grid-color)')
+                .style('opacity', '1');
+        }
+        if (this.chartConfiguration.xAxisGrid) {
+            for (let j = 0; j < this.chartConfiguration.xAxisGrid.length; j++) {
+                svg
+                    .append('g')
+                    .attr('class', `x${j + 2} axis${j + 2}`)
+                    .style('color', 'var(--chart-grid-color)')
+                    .attr('transform', `translate(0,${dimensions.height * this.chartConfiguration.xAxisGrid[j]})`)
+                    .call(d3.axisBottom(scales.xScale).tickSize(0).ticks(5).tickFormat(''))
+                    .style('fill', 'var(--chart-text-color)');
+            }
+        }
+    }
+    renderAxes(svg, svgYAxisLeft, svgYAxisRight, axes, scales, dimensions, device, data) {
+        if (this.chartConfiguration.showXaxisTop) {
+            svg
+                .append('g')
+                .attr('class', 'lib-line-axis-text lib-line-x-axis-text x-axis')
+                .attr('style', this.chartConfiguration.xAxisCustomTextStyles)
+                .call(d3.axisBottom(scales.xScale).tickSize(0));
+            svg.selectAll('.x-axis > g > text').attr('class', 'lib-display-hidden');
+        }
+        if (!this.chartConfiguration.isMultiChartGridLine) {
+            this.renderStandardAxes(svg, axes, scales, dimensions, device, data);
         }
         else if (this.chartConfiguration.isDrilldownChart) {
-            this.renderDrilldownAxes(svg, svgYAxisLeft, svgYAxisRight, xAxis, yAxis, height);
+            this.renderDrilldownAxes(svg, svgYAxisLeft, svgYAxisRight, axes, scales, dimensions);
         }
         else {
-            this.renderMultiChartAxes(svg, xAxis, yAxis, height);
+            this.renderMultiChartAxes(svg, axes, scales, dimensions);
         }
-        this.styleAxisDomains(svg, svgYAxisLeft, svgYAxisRight);
+        this.applyAxisStyling(svg, svgYAxisLeft, svgYAxisRight);
+        this.applyAxisConfigurations(svg, scales, dimensions, data);
     }
-    renderStandardAxes(svg, xAxis, yAxis, data, height, device) {
+    renderStandardAxes(svg, axes, scales, dimensions, device, data) {
         if (device.isMobile) {
-            this.renderMobileXAxis(svg, data, height, device);
+            this.renderMobileXAxis(svg, data, dimensions);
         }
         else {
             svg
                 .append('g')
-                .attr('transform', `translate(0,${height})`)
+                .attr('transform', `translate(0,${dimensions.height})`)
                 .attr('class', 'lib-stacked-x-axis-text')
-                .call(xAxis)
+                .call(axes.xAxis)
                 .selectAll('text')
                 .style('fill', 'var(--chart-text-color)')
                 .style('font-size', '12px')
-                .attr('text-anchor', 'middle');
+                .attr('text-anchor', 'middle')
+                .attr('dx', '0')
+                .attr('dy', '0.71em')
+                .attr('transform', null);
         }
         svg
             .append('g')
             .attr('class', 'lib-stacked-y-axis-text')
-            .call(yAxis)
+            .attr('style', this.chartConfiguration.yAxisCustomTextStyles)
+            .call(axes.yAxis)
             .selectAll('text')
             .style('fill', 'var(--chart-text-color)');
     }
-    renderMobileXAxis(svg, data, height, device) {
-        const barWidth = 32;
-        const barPadding = 12;
+    renderMobileXAxis(svg, data, dimensions) {
         svg.selectAll('.custom-x-label').remove();
         data.forEach((d, i) => {
-            const xVal = this.SPACING.leftAndRight + i * (barWidth + barPadding) + barWidth / 2;
+            const xVal = this.CONSTANTS.LEFT_RIGHT_SPACES +
+                i * (dimensions.barWidth + dimensions.barPadding) +
+                dimensions.barWidth / 2;
             svg
                 .append('text')
                 .attr('class', 'custom-x-label')
                 .attr('x', 0)
-                .attr('y', height + 18)
+                .attr('y', dimensions.height + 18)
                 .attr('text-anchor', 'middle')
                 .attr('transform', `translate(${xVal + 20},0)`)
                 .style('font-size', '10px')
@@ -7115,204 +7273,350 @@ class HorizontalBarsWithScrollZoomComponent extends ComponentUniqueId {
                 .text(d.name.substring(0, 3));
         });
     }
-    renderDrilldownAxes(svg, svgYAxisLeft, svgYAxisRight, xAxis, yAxis, height) {
+    renderDrilldownAxes(svg, svgYAxisLeft, svgYAxisRight, axes, scales, dimensions) {
         svg
             .append('g')
-            .attr('transform', `translate(0,${height})`)
+            .attr('transform', `translate(0,${dimensions.height})`)
             .attr('class', 'lib-stacked-x-axis-text multichart1')
-            .call(xAxis)
+            .call(axes.xAxis)
             .style('display', 'none');
         svgYAxisLeft
             .append('g')
             .attr('class', 'lib-yaxis-labels-texts-drilldown yaxis-dashed')
-            .call(yAxis)
+            .attr('style', this.chartConfiguration.yAxisCustomTextStyles)
+            .call(axes.yAxis)
             .selectAll('text')
             .style('fill', 'var(--chart-text-color)');
         svgYAxisRight
             .append('g')
             .attr('class', 'lib-yaxis-labels-texts-drilldown yaxis-dashed')
-            .call(yAxis)
+            .attr('style', this.chartConfiguration.yAxisCustomTextStyles)
+            .call(axes.yAxis)
             .style('display', 'none');
     }
-    renderMultiChartAxes(svg, xAxis, yAxis, height) {
+    renderMultiChartAxes(svg, axes, scales, dimensions) {
         svg
             .append('g')
-            .attr('transform', `translate(0,${height})`)
+            .attr('transform', `translate(0,${dimensions.height})`)
             .attr('class', 'lib-stacked-x-axis-text multichart')
-            .call(xAxis)
+            .call(axes.xAxis)
             .selectAll('text')
             .style('fill', 'var(--chart-text-color)');
         svg
             .append('g')
             .attr('class', 'lib-stacked-y-axis-text yaxis-dashed')
-            .call(yAxis)
+            .attr('style', this.chartConfiguration.yAxisCustomTextStyles)
+            .call(axes.yAxis)
             .selectAll('text')
             .style('fill', 'var(--chart-text-color)');
     }
-    styleAxisDomains(svg, svgYAxisLeft, svgYAxisRight) {
-        const axisStyle = {
-            stroke: 'var(--chart-axis-color)',
-            'stroke-width': '1px'
+    applyAxisStyling(svg, svgYAxisLeft, svgYAxisRight) {
+        const styleAxisDomain = (container) => {
+            container.selectAll('.domain')
+                .style('stroke', 'var(--chart-axis-color)')
+                .style('stroke-width', '1px');
         };
-        [svg, svgYAxisLeft, svgYAxisRight].forEach(element => {
-            element.selectAll('.domain')
-                .style('stroke', axisStyle.stroke)
-                .style('stroke-width', axisStyle['stroke-width']);
-        });
-    }
-    renderLabels(svg, svgYAxisLeft, metaData, height, width, margin) {
-        if (metaData.yLabel) {
-            this.renderYAxisLabel(svgYAxisLeft, metaData.yLabel, height, margin);
+        styleAxisDomain(svg);
+        styleAxisDomain(svgYAxisLeft);
+        styleAxisDomain(svgYAxisRight);
+        if (this.chartConfiguration.isYaxisDashed) {
+            d3.selectAll('.yaxis-dashed')
+                .style('stroke-dasharray', '5 5')
+                .style('color', 'var(--chart-grid-color)');
         }
-        if (metaData.xLabel) {
-            this.renderXAxisLabel(svg, metaData.xLabel, height, width, margin);
+        if (this.chartConfiguration.isXaxisColor) {
+            d3.selectAll('.multichart').style('color', this.chartConfiguration.isXaxisColor || 'var(--chart-text-color)');
         }
     }
-    renderYAxisLabel(svgYAxisLeft, yLabel, height, margin) {
-        svgYAxisLeft.selectAll('.lib-axis-group-label, .lib-ylabel-drilldowncharts, .lib-ylabel-weeklyCharts').remove();
-        const { formatted, isAcronym } = this.formatAxisLabel(yLabel);
-        const isRia = this.customChartConfiguration?.isRia;
-        const yPosition = isRia ? -margin.left / 2 - 30 : -margin.left / 2 - 40;
-        let labelClass = 'lib-axis-group-label font-size-1';
-        if (this.chartConfiguration.isDrilldownChart) {
-            labelClass += ' lib-ylabel-drilldowncharts';
+    applyAxisConfigurations(svg, scales, dimensions, data) {
+        if (this.chartConfiguration.isMultiChartGridLine !== undefined) {
+            d3.selectAll('.multichart > g > text').attr('class', 'lib-display-hidden');
         }
-        else if (this.chartConfiguration.isMultiChartGridLine !== undefined) {
-            labelClass += ' lib-ylabel-weeklyCharts';
+        if (this.chartConfiguration.isXaxisLabelHidden) {
+            d3.selectAll('.multichart > g > text').attr('class', 'lib-display-hidden');
         }
-        else {
-            labelClass += ' lib-axis-waterfall-label';
+        else if (this.chartConfiguration.isXaxisLabelHidden !== undefined) {
+            this.renderCustomXAxis(svg, scales, dimensions, data);
         }
-        svgYAxisLeft
+        if (this.chartConfiguration.isYaxisLabelHidden) {
+            svg.selectAll('.yaxis-dashed > g > text').attr('class', 'lib-display-hidden');
+        }
+        if (this.chartConfiguration.isYaxisHidden) {
+            d3.selectAll('.yaxis-dashed').attr('class', 'lib-display-hidden');
+        }
+        if (this.isZoomedOut && data.length > 9) {
+            svg
+                .selectAll('.lib-xaxis-labels-texts-drilldown')
+                .attr('transform', 'rotate(-90)')
+                .attr('text-anchor', 'end')
+                .attr('x', '-5')
+                .attr('dy', null);
+        }
+    }
+    renderCustomXAxis(svg, scales, dimensions, data) {
+        const device = this.getDeviceConfig();
+        svg
+            .append('g')
+            .attr('class', 'x1 axis1')
+            .attr('transform', `translate(0,${dimensions.height})`)
+            .style('color', '#000')
+            .call(d3.axisBottom(scales.xScale).tickSize(0))
+            .call((g) => g.select('.domain').attr('fill', 'none'));
+        this.styleCustomXAxisTicks(svg, data, device);
+        if (this.chartConfiguration.xLabelsOnSameLine) {
+            this.applyXLabelsOnSameLine(svg, device);
+        }
+    }
+    styleCustomXAxisTicks(svg, data, device) {
+        let alternateText = false;
+        svg.selectAll('.x1.axis1 .tick line').attr('y2', () => {
+            if (this.chartConfiguration.hideXaxisTick)
+                return 0;
+            if (alternateText && !this.chartConfiguration.isNoAlternateXaxisText) {
+                alternateText = false;
+                return this.CONSTANTS.LONG_TICK_LENGTH_BG - 7;
+            }
+            alternateText = true;
+            return this.CONSTANTS.SHORT_TICK_LENGTH_BG - 4;
+        });
+        alternateText = false;
+        svg
+            .selectAll('g.x1.axis1 g.tick text')
+            .attr('class', () => {
+            if (this.chartConfiguration.isDrilldownChart) {
+                return data.length > 8
+                    ? 'lib-xaxis-labels-texts-drilldown-alt'
+                    : 'lib-xaxis-labels-texts-drilldown';
+            }
+            return 'lib-xaxis-labels-texts-weeklycharts';
+        })
+            .attr('y', () => {
+            if (alternateText) {
+                alternateText = false;
+                return this.CONSTANTS.LONG_TICK_LENGTH_BG;
+            }
+            alternateText = true;
+            return this.CONSTANTS.SHORT_TICK_LENGTH_BG;
+        });
+    }
+    applyXLabelsOnSameLine(svg, device) {
+        svg
+            .selectAll('g.x1.axis1 g.tick text')
+            .attr('class', 'lib-xaxis-labels-texts-drilldown')
+            .attr('y', this.CONSTANTS.SHORT_TICK_LENGTH_BG)
+            .text((d) => {
+            if (device.isMobile) {
+                return d.split(' ')[0].substring(0, 3);
+            }
+            const trimmed = d.trim();
+            const spaceIndex = trimmed.indexOf(' ');
+            return spaceIndex > -1
+                ? trimmed.substring(0, spaceIndex).toLowerCase()
+                : trimmed.toLowerCase();
+        })
+            .attr('transform', function (d, i) {
+            if (device.isMobile) {
+                const parent = this.parentNode?.parentNode;
+                const totalBars = parent ? d3.select(parent).selectAll('g.tick').size() : 0;
+                return totalBars === 2 ? 'translate(0,0)' : `translate(${i * 30},0)`;
+            }
+            return null;
+        });
+        svg
+            .selectAll('g.x1.axis1 g.tick')
             .append('text')
-            .attr('class', labelClass)
-            .attr('style', this.chartConfiguration.yAxisCustomlabelStyles)
-            .attr('transform', 'rotate(-90)')
-            .attr('y', yPosition)
-            .attr('x', -height / 2)
-            .attr('dy', '1em')
-            .style('text-anchor', 'middle')
-            .style('fill', 'var(--chart-text-color)')
-            .text(formatted)
-            .style('text-transform', isAcronym ? 'none' : 'capitalize');
+            .attr('class', 'lib-xaxis-labels-texts-drilldown')
+            .attr('y', this.CONSTANTS.LONG_TICK_LENGTH_BG)
+            .attr('fill', 'currentColor')
+            .text((d) => {
+            if (device.isMobile)
+                return '';
+            const trimmed = d.trim();
+            const spaceIndex = trimmed.indexOf(' ');
+            return spaceIndex > -1
+                ? trimmed.substring(spaceIndex).toLowerCase()
+                : '';
+        })
+            .attr('transform', (d, i) => {
+            return device.isMobile && i === 0 ? 'translate(20,0)' : null;
+        });
     }
-    renderXAxisLabel(svg, xLabel, height, width, margin) {
-        const { formatted, isAcronym } = this.formatAxisLabel(xLabel);
-        const isRia = this.customChartConfiguration?.isRia;
-        const xPosition = isRia
-            ? height + margin.top + margin.bottom
-            : height + margin.top + margin.bottom + 10;
-        let labelClass = 'lib-axis-group-label font-size-1';
-        if (this.chartConfiguration.isDrilldownChart) {
-            labelClass += ' lib-xlabel-drilldowncharts';
+    renderDataLabels(rect, scales, metaData, dimensions) {
+        if (!this.isCC && !this.chartConfiguration.isMultiChartGridLine) {
+            rect.append('svg:title').text((d) => d[1] - d[0]);
         }
-        else if (this.chartConfiguration.isMultiChartGridLine !== undefined) {
-            labelClass += ' lib-xlabel-weeklyCharts';
+        if (this.chartConfiguration.showTotalOnTop) {
+            this.renderTopLabels(rect, scales, metaData);
         }
-        else {
-            labelClass += ' lib-axis-waterfall-label';
+        if (this.chartConfiguration.showAngledLabels) {
+            this.renderAngledLabels(rect, scales, metaData);
         }
-        svg
+    }
+    renderTopLabels(rect, scales, metaData) {
+        const formatFromBackend = this.chartConfiguration.textFormatter
+            ? ChartHelper.dataValueFormatter(this.chartConfiguration.textFormatter)
+            : (d) => d;
+        const formatForHugeNumbers = ChartHelper.dataValueFormatter('.2s');
+        rect
             .append('text')
-            .attr('class', labelClass)
-            .attr('style', this.chartConfiguration.xAxisCustomlabelStyles)
-            .attr('transform', `translate(${width / 2},${xPosition})`)
-            .style('text-anchor', 'middle')
-            .style('fill', 'var(--chart-text-color)')
-            .text(formatted)
-            .style('text-transform', isAcronym ? 'none' : 'capitalize');
+            .attr('x', (d) => scales.xScale(d.data.name) + scales.xScale.bandwidth() / 2)
+            .attr('class', 'lib-verticalstack-labels-ontop-weklycharts')
+            .attr('y', (d) => scales.yScale(d[1]) - 3)
+            .text((d) => {
+            const value = d[1] - d[0];
+            if (isNaN(value) || value === 0)
+                return;
+            const formattedValue = value <= 999
+                ? formatFromBackend(value)
+                : formatForHugeNumbers(value);
+            return metaData.unit ? metaData.unit + formattedValue : formattedValue;
+        });
     }
-    renderTargetLine(svg, svgYAxisRight, yScale, width, targetValue, metaData) {
-        const yZero = yScale(targetValue);
-        // Draw target line
+    renderAngledLabels(rect, scales, metaData) {
+        const formatFromBackend = this.chartConfiguration.textFormatter
+            ? ChartHelper.dataValueFormatter(this.chartConfiguration.textFormatter)
+            : (d) => d;
+        const formatForHugeNumbers = ChartHelper.dataValueFormatter('.2s');
+        const tempObjectHolder = {};
+        rect
+            .append('text')
+            .attr('x', 0)
+            .attr('y', 0)
+            .attr('fill', (d) => metaData.colors[d.key])
+            .attr('class', 'lib-data-labels-angled-weeklycharts')
+            .text((d) => {
+            const value = d[1] - d[0];
+            if (isNaN(value) || value <= 0)
+                return;
+            const formattedValue = value <= 999
+                ? formatFromBackend(value)
+                : formatForHugeNumbers(value);
+            return metaData.unit ? metaData.unit + formattedValue : formattedValue;
+        })
+            .attr('transform', (d) => {
+            const value = d[1] - d[0];
+            if (isNaN(value) || value <= 0)
+                return 'rotate(0)';
+            let total = 0;
+            let incrementer = 1;
+            metaData.keyList.forEach(key => {
+                if (d.data[key]) {
+                    total += d.data[key];
+                }
+                else {
+                    incrementer = 2;
+                }
+            });
+            tempObjectHolder[d.data.name] = (tempObjectHolder[d.data.name] || 0) + incrementer;
+            const position = tempObjectHolder[d.data.name];
+            const xPos = scales.xScale(d.data.name);
+            const bandwidth = scales.xScale.bandwidth();
+            const yPos = scales.yScale(total) - 3;
+            switch (position) {
+                case 1:
+                    return `translate(${xPos + bandwidth / 3},${yPos}) rotate(270)`;
+                case 2:
+                    return `translate(${xPos + bandwidth / 2 + 2},${yPos}) rotate(270)`;
+                default:
+                    return `translate(${xPos + (bandwidth * 3) / 4},${yPos}) rotate(270)`;
+            }
+        });
+    }
+    renderTargetLine(svg, svgYAxisRight, scales, dimensions, metaData) {
+        if (!this.chartData.targetLineData)
+            return;
+        const parsedTarget = this.parseTargetValue(this.chartData.targetLineData.target);
+        const yZero = scales.yScale(parsedTarget);
         svg
             .append('line')
             .attr('x1', 0)
-            .attr('x2', width)
+            .attr('x2', dimensions.width)
             .attr('y1', yZero)
             .attr('y2', yZero)
             .style('stroke-dasharray', '5 5')
             .style('stroke', this.chartData.targetLineData.color);
-        // Add target label
-        const targetLineName = this.chartData.targetLineData?.targetName || 'target';
+        this.renderTargetLabel(svgYAxisRight, yZero, metaData);
+    }
+    parseTargetValue(target) {
+        const parsed = parseFloat(String(target));
+        if (isNaN(parsed))
+            return 0;
+        return Number.isInteger(parsed) ? parseInt(String(target)) : parsed;
+    }
+    renderTargetLabel(svgYAxisRight, yZero, metaData) {
         const dataType = metaData.dataType || '';
+        const targetName = this.chartData.targetLineData.targetName || 'target';
         svgYAxisRight
             .append('foreignObject')
             .attr('transform', `translate(0,${yZero - 13})`)
-            .attr('width', this.SPACING.rightSvgWidth)
+            .attr('width', this.CONSTANTS.RIGHT_SVG_WIDTH)
             .attr('height', 50)
             .append('xhtml:div')
             .attr('class', 'target-display')
             .style('color', 'var(--chart-text-color)')
-            .html(`
-        <div>${targetLineName}</div>
-        <div>${targetValue}${dataType}</div>
-      `);
+            .html(`<div>${targetName}</div><div>${this.chartData.targetLineData.target}${dataType}</div>`);
     }
-    renderLineChart(svg, lineData, xScale, height, colors) {
-        const lineYscale = d3
-            .scaleLinear()
-            .domain([0, d3.max(lineData, (d) => +d.value) || 0])
-            .range([height, 0]);
+    renderLineChart(svg, lineData, scales, colors, metaData) {
+        if (!lineData || !colors)
+            return;
         const dataGroup = d3
             .nest()
             .key((d) => d.category)
             .entries(lineData);
         const lineGen = d3
             .line()
-            .x((d) => xScale(d.name) + xScale.bandwidth() / 2)
-            .y((d) => lineYscale(d.value));
+            .x((d) => scales.xScale(d.name) + scales.xScale.bandwidth() / 2)
+            .y((d) => scales.lineYscale(d.value));
         dataGroup.forEach((group) => {
-            // Draw line
             svg
                 .append('path')
                 .datum(group.values)
                 .attr('fill', 'none')
                 .attr('stroke', (d) => {
-                if (d[0] && 'category' in d[0]) {
-                    return colors[d[0].category];
-                }
-                return this.chartConfiguration.lineGraphColor;
+                return d[0]?.category
+                    ? colors[d[0].category]
+                    : this.chartConfiguration.lineGraphColor;
             })
                 .attr('stroke-width', 2.5)
-                .attr('d', lineGen(group.values));
-            // Draw dots
-            const dot = svg
-                .selectAll('myCircles')
-                .data(group.values)
-                .enter()
-                .append('g')
-                .on('click', (d) => this.handleClick(d));
-            dot
-                .append('circle')
-                .attr('fill', (d) => {
-                if ('category' in d) {
-                    return colors[d.category];
-                }
-                return this.chartConfiguration.lineGraphColor;
-            })
-                .attr('stroke', 'none')
-                .attr('cx', (d) => xScale(d.name) + xScale.bandwidth() / 2)
-                .attr('cy', (d) => lineYscale(d.value))
-                .attr('r', 3)
-                .style('cursor', 'pointer');
-            // Add labels if configured
-            if (this.chartConfiguration.lineGraphColor) {
-                dot
-                    .append('text')
-                    .attr('class', 'dots')
-                    .attr('fill', this.chartConfiguration.lineGraphColor)
-                    .attr('style', 'font-size: 0.85em; font-weight: bold')
-                    .attr('x', (d) => xScale(d.name) + xScale.bandwidth() / 2)
-                    .attr('y', (d) => lineYscale(d.value))
-                    .attr('dy', '-1em')
-                    .text((d) => this.chartConfiguration.labelFormatter(d.value));
-            }
+                .attr('d', lineGen);
+            this.renderLineDots(svg, group.values, scales, colors);
         });
     }
-    handleClick(data) {
-        if (this.chartData?.metaData?.hasDrillDown || data?.toggleFrom) {
-            this.clickEvent.emit(data);
+    renderLineDots(svg, values, scales, colors) {
+        const dot = svg
+            .selectAll('.line-dots')
+            .data(values)
+            .enter()
+            .append('g')
+            .on('click', (d) => this.handleClick(d));
+        dot
+            .append('circle')
+            .attr('fill', (d) => {
+            return d.category
+                ? colors[d.category]
+                : this.chartConfiguration.lineGraphColor;
+        })
+            .attr('stroke', 'none')
+            .attr('cx', (d) => scales.xScale(d.name) + scales.xScale.bandwidth() / 2)
+            .attr('cy', (d) => scales.lineYscale(d.value))
+            .attr('r', 3)
+            .style('cursor', 'pointer');
+        if (this.chartConfiguration.lineGraphColor) {
+            dot
+                .append('text')
+                .attr('class', 'dots')
+                .attr('fill', this.chartConfiguration.lineGraphColor)
+                .style('font-size', '.85em')
+                .style('font-weight', 'bold')
+                .attr('x', (d) => scales.xScale(d.name) + scales.xScale.bandwidth() / 2)
+                .attr('y', (d) => scales.lineYscale(d.value))
+                .attr('dy', '-1em')
+                .text((d) => this.chartConfiguration.labelFormatter(d.value));
+        }
+    }
+    handleClick(d) {
+        if (this.chartData?.metaData?.hasDrillDown || d?.toggleFrom) {
+            this.clickEvent.emit(d);
         }
     }
     handleHeaderMenuClick(id) {
@@ -7455,6 +7759,9 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
         var alternate_text = false;
         var short_tick_length = 4;
         var long_tick_length = 16;
+        /**
+         * longer tick length needed for weekly charts
+         */
         var short_tick_length_bg = 5;
         var long_tick_length_bg = 30;
         var leftAndRightSpaces = 50;
@@ -7466,6 +7773,9 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
         data = this.chartData.data;
         metaData = this.chartData.metaData;
         lineData = this.chartData.lineData;
+        // if (lineData || this.chartData.targetLineData) {
+        //   rightSvgWidth = 60;
+        // }
         if (!metaData.colorAboveTarget) {
             metaData['colorAboveTarget'] = metaData.colors;
         }
@@ -7502,10 +7812,16 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             else
                 width = this.chartData.data.length * 160;
         }
+        // if (this.chartData.data.length > 8) {
+        //   width = this.chartData.data.length * 140;
+        // }
         var height = parseInt(verticalstackedcontainer.style('height')) *
             (self.chartConfiguration.svgHeight / 100) -
             margin.top -
             margin.bottom;
+        /**
+         * entire height used in weekly charts as x axis needed to be displayed at the bottom of the chart
+         */
         if (this.chartConfiguration.isFullScreen != undefined &&
             this.chartConfiguration.isFullScreen) {
             height =
@@ -7527,15 +7843,30 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                     margin.bottom -
                     100;
         }
+        /**
+         * for hiding header
+         * used by weekly charts
+         */
         if (this.chartConfiguration.isHeaderVisible != undefined)
             this.isHeaderVisible = this.chartConfiguration.isHeaderVisible;
+        /**
+         * for hiding legends
+         * used by weekly charts
+         */
         if (this.chartConfiguration.legendVisible != undefined) {
             this.legendVisible = this.chartConfiguration.legendVisible;
         }
+        /**
+         * for removing background color so that it can take parents color
+         *
+         */
         if (this.chartConfiguration.isTransparentBackground != undefined) {
             this.isTransparentBackground =
                 this.chartConfiguration.isTransparentBackground;
         }
+        /**
+         * format data values based on configuration received
+         */
         if (this.chartConfiguration.textFormatter != undefined) {
             formatFromBackend = ChartHelper.dataValueFormatter(this.chartConfiguration.textFormatter);
             formatForHugeNumbers = ChartHelper.dataValueFormatter('.2s');
@@ -7548,6 +7879,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             .style('height', height)
             .style('overflow-x', 'hidden')
             .style('padding-left', `${margin.left}px`)
+            // .call(ChartHelper.responsivefy)
             .style('padding-right', `${rightSvgWidth}px`)
             .style('margin-left', '15px');
         var svgYAxisLeft = outerContainer
@@ -7575,8 +7907,10 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             .style('overflow-x', 'auto');
         var svg = innerContainer
             .append('svg')
+            // .attr('id', self.uniqueId)
             .attr('width', width - rightSvgWidth)
             .attr('height', height + margin.top + margin.bottom + 60)
+            // .call(ChartHelper.responsivefy)
             .append('g')
             .attr('transform', 'translate(' + 0 + ',' + margin.top + ')');
         var subgroups = keyList;
@@ -7585,6 +7919,9 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             return d.name;
         })
             .keys();
+        /**
+         * x axis range made similar to line chart or vertical stack so that all the charts will get aligned with each other.
+         */
         if (this.chartConfiguration.isMultiChartGridLine != undefined) {
             x = d3
                 .scaleBand()
@@ -7602,11 +7939,27 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 .range([leftAndRightSpaces, width - rightSvgWidth - leftAndRightSpaces])
                 .padding([0.3]);
         }
+        // x.bandwidth(96);
         var xScaleFromOrigin = d3
             .scaleBand()
             .domain(groups)
             .range([0, width - rightSvgWidth]);
+        // .padding([0.2]);
+        /**
+         * draw second x axis on top
+         */
+        // if (self.chartConfiguration.showXaxisTop) {
+        //   svg
+        //     .append('g')
+        //     .attr('class', 'lib-line-axis-text lib-line-x-axis-text x-axis')
+        //     .attr('style', self.chartConfiguration.xAxisCustomTextStyles)
+        //     .call(d3.axisBottom(x).tickSize(0));
+        // }
+        // d3.svg.axis().scale(x).orient('bottom').ticks(1).innerTickSize(-height);
         if (this.chartConfiguration.isMultiChartGridLine == undefined) {
+            /**
+             * normal ticks for all dashboard charts
+             */
             svg
                 .append('g')
                 .attr('class', 'x1 axis1')
@@ -7614,12 +7967,13 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 .call(d3.axisBottom(x))
                 .call((g) => g.select('.domain').remove());
             svg.selectAll('g.x1.axis1 g.tick line').remove();
+            // Only move x-axis labels further down for grouped charts if there is no xLabel
             if (subgroups.length > 1 && !metaData.xLabel) {
                 svg
                     .selectAll('g.x1.axis1 g.tick text')
                     .attr('class', 'lib-xaxis-labels-texts-drilldown')
                     .style('fill', 'var(--chart-text-color)')
-                    .attr('y', 32);
+                    .attr('y', 32); // Increase distance from bars (default is ~9)
             }
             else {
                 svg
@@ -7627,14 +7981,32 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                     .attr('class', 'lib-xaxis-labels-texts-drilldown')
                     .style('fill', 'var(--chart-text-color)');
             }
+            // .attr('y', function () {
+            //   if (alternate_text) {
+            //     alternate_text = false;
+            //     return long_tick_length + 1;
+            //   } else {
+            //     alternate_text = true;
+            //     return short_tick_length + 1;
+            //   }
+            // });
         }
         else {
+            /**
+             * bigger ticks for weekly charts and more space from x axis to labels
+             */
+            /**
+             * draw x axis
+             */
             svg
                 .append('g')
                 .attr('class', 'x1 axis1')
                 .attr('transform', 'translate(0,' + height + ')')
                 .call(d3.axisBottom(x).tickSize(0))
                 .call((g) => g.select('.domain').attr('fill', 'none'));
+            /**
+             * tick line size in alternate fashion
+             */
             svg.selectAll('g.x1.axis1 g.tick line').attr('y2', function () {
                 if (alternate_text &&
                     self.chartConfiguration.isNoAlternateXaxisText == undefined) {
@@ -7646,11 +8018,19 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                     return short_tick_length_bg - 4;
                 }
             });
+            /**
+             * reset the flag so that values can be shown in same alternate fashion
+             */
             alternate_text = false;
+            /**
+             * print x-axis label texts
+             * used by weekly charts
+             */
             svg
                 .selectAll('g.x1.axis1 g.tick text')
                 .attr('class', 'lib-xaxis-labels-texts-weeklycharts')
                 .attr('y', function () {
+                // Minimize gap in maximized (fullscreen) view for weekly charts
                 if (self.chartConfiguration.isFullScreen) {
                     return short_tick_length_bg;
                 }
@@ -7671,6 +8051,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 .style('font-size', this.isHeaderVisible ? '18px' : '14px')
                 .attr('text-anchor', 'middle')
                 .attr('y', function (d) {
+                // For grouped bar charts with many bars and xLabel present, only add 5 if the label is a date
                 if (subgroups.length > 1 && data.length > 8 && metaData.xLabel) {
                     const isDateLabel = /\d{2,4}[-\/]/.test(d);
                     if (self.chartConfiguration.isFullScreen) {
@@ -7678,13 +8059,16 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                     }
                     return isDateLabel ? short_tick_length_bg + 14 : short_tick_length_bg;
                 }
+                // For grouped bar charts with many bars and NO xLabel, add space as before, but reduce in fullscreen
                 if (subgroups.length > 1 && data.length > 8 && !metaData.xLabel) {
                     const chartHasExtraBottom = (self.chartConfiguration.margin && self.chartConfiguration.margin.bottom >= 40);
                     if (self.chartConfiguration.isFullScreen) {
+                        // Reduce extra gap in maximized view
                         return short_tick_length_bg + 2;
                     }
                     return chartHasExtraBottom ? short_tick_length_bg : short_tick_length_bg + 10;
                 }
+                // Default/fallback logic for other cases
                 let baseY = self.isHeaderVisible ? short_tick_length_bg + 25 : short_tick_length_bg;
                 if (subgroups.length > 1 &&
                     !metaData.xLabel &&
@@ -7694,6 +8078,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 if (/\d{2,4}[-\/]\d{2,4}/.test(d) && d.indexOf(' ') > -1) {
                     baseY += 4;
                 }
+                // In maximized view, reduce baseY slightly for grouped bars
                 if (self.chartConfiguration.isFullScreen && subgroups.length > 1) {
                     baseY = Math.max(short_tick_length_bg, baseY - 10);
                 }
@@ -7701,9 +8086,9 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             })
                 .attr('x', function (d) {
                 if (self.chartData.data.length > 8 && !self.isZoomedOut) {
-                    return 1;
+                    return 1; // Move first line text slightly to the left in zoom-in view for better alignment
                 }
-                return 0;
+                return 0; // Default position
             })
                 .text(function (d) {
                 var isValueToBeIgnored = false;
@@ -7721,10 +8106,13 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 if (isValueToBeIgnored) {
                     return '';
                 }
+                // Always add space before and after hyphen for date range labels, even when header is visible and label is single line
+                // Apply for grouped bar charts and single bar charts, header visible, single line
                 const dateRangeRegex = /(\d{2,4}[-\/]\d{2}[-\/]\d{2,4})\s*-\s*(\d{2,4}[-\/]\d{2}[-\/]\d{2,4})/;
                 if (dateRangeRegex.test(d.trim())) {
                     return d.trim().replace(dateRangeRegex, (m, d1, d2) => `${d1} - ${d2}`);
                 }
+                // Split date and week labels into two lines in grouped bar zoom-in view (and minimized view)
                 const isDateLabel = /\d{2,4}[-\/]/.test(d);
                 const isWeekLabel = /week|wk|w\d+/i.test(d);
                 if (subgroups.length > 1 && !self.isZoomedOut && data.length > 8 && d.indexOf(' ') > -1 && (isDateLabel || isWeekLabel)) {
@@ -7732,6 +8120,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                     var second = d.substring(d.indexOf(' ') + 1).trim();
                     return first + '\n' + second;
                 }
+                // Also keep previous logic for minimized view
                 if (isDateLabel) {
                     if (!self.isHeaderVisible && data.length > 8 && d.indexOf(' ') > -1) {
                         var first = d.substring(0, d.indexOf(' '));
@@ -7746,7 +8135,9 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                     return d.trim().substring(0, d.indexOf(' ')).toLowerCase();
                 }
                 return d.toLowerCase();
+                // If label looks like a date (contains digits and - or /)
                 const isDateLabel2 = /\d{2,4}[-\/]/.test(d);
+                // Only split date/week labels if there are many grouped bars and header is not visible
                 if (isDateLabel) {
                     if (!self.isHeaderVisible && data.length > 8 && d.indexOf(' ') > -1) {
                         var first = d.substring(0, d.indexOf(' '));
@@ -7762,7 +8153,9 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 }
                 return d.toLowerCase();
             });
+            // Now apply writing-mode: sideways-lr for grouped charts with date labels in zoomed-out view and many bars
             xAxisLabels.each(function (d) {
+                // Only apply writing-mode for exact date labels, not those containing 'week' or similar
                 const isDateLabel = /^(\d{2,4}[-\/])?\d{2,4}[-\/]\d{2,4}$/.test(d.trim());
                 const isWeekLabel = /week|wk|w\d+/i.test(d);
                 if (subgroups.length > 1 && self.isZoomedOut && data.length > 8 && isDateLabel && !isWeekLabel) {
@@ -7773,7 +8166,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 svg
                     .selectAll('g.x1.axis1 g.tick')
                     .filter(function (d) {
-                    return !/\d{2,4}[-\/]/.test(d);
+                    return !/\d{2,4}[-\/]/.test(d); // Only process non-date labels
                 })
                     .append('text')
                     .attr('class', 'lib-xaxis-labels-texts-drilldown')
@@ -7781,9 +8174,9 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                     .attr('fill', 'var(--chart-text-color)')
                     .attr('x', function (d) {
                     if (self.chartData.data.length > 8 && !self.isZoomedOut) {
-                        return 1;
+                        return 1; // Move text slightly to the left
                     }
-                    return 0;
+                    return 0; // Default position
                 })
                     .text(function (d) {
                     if (d.trim().indexOf(' ') > -1) {
@@ -7810,6 +8203,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 .selectAll('g.x1.axis1 g.tick text')
                 .classed('mobile-xaxis-override', true);
         }
+        /**y scale for left y axis */
         var y = d3.scaleLinear().rangeRound([height, 0]);
         var maxValue = d3.max(data, (d) => d3.max(keyList, (key) => +d[key]));
         if (maxValue == 0) {
@@ -7820,7 +8214,27 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 maxValue = 100;
             }
         }
+        if (self.chartConfiguration.yAxisGrid) {
+            // svg
+            //   .append('g')
+            //   .attr('class', 'grid')
+            //   .call(
+            //     d3
+            //       .axisLeft(y)
+            //       .ticks(self.chartConfiguration.numberOfYTicks)
+            //       .tickSize(-width)
+            //       .tickFormat('')
+            //   )
+            //   // .style('stroke-dasharray', '5 5')
+            //   .style('color', '#B9B9B9')
+            //   .style('opacity', '0.5')
+            //   .call((g) => g.select('.domain').remove());
+        }
         if (this.chartConfiguration.customYscale) {
+            /**
+             * increase y-scale so that values wont cross or exceed out of range
+             * used in weekly charts
+             */
             maxValue = maxValue * this.chartConfiguration.customYscale;
         }
         if (this.chartData.targetLineData &&
@@ -7858,6 +8272,10 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 .tickSize(0)
                 .tickFormat(self.chartConfiguration.yLineAxisLabelFomatter);
         }
+        /**
+         * show x-axis grid between labels
+         * used by weekly charts
+         */
         if (self.chartConfiguration.isXgridBetweenLabels) {
             svg
                 .append('g')
@@ -7865,7 +8283,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 .attr('transform', 'translate(' + x.bandwidth() / 2 + ',' + height + ')')
                 .call(d3.axisBottom(x).tickSize(-height).tickFormat(''))
                 .style('stroke-dasharray', '5 5')
-                .style('color', 'var(--chart-grid-color, #999999)')
+                .style('color', 'var(--chart-grid-color, #999999)') // Use CSS variable
                 .call((g) => g.select('.domain').remove());
         }
         if (this.chartConfiguration.yAxisGrid) {
@@ -7880,7 +8298,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 .call((g) => {
                 g.select('.domain')
                     .remove()
-                    .style('stroke', 'var(--chart-domain-color, #000000)');
+                    .style('stroke', 'var(--chart-domain-color, #000000)'); // Add CSS variable for domain
             });
         }
         else {
@@ -7891,27 +8309,36 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 .style('opacity', '0.5')
                 .call((g) => {
                 g.select('.domain')
-                    .style('stroke', 'var(--chart-domain-color, #000000)')
-                    .style('stroke-width', '1px');
+                    .style('stroke', 'var(--chart-domain-color, #000000)') // Add CSS variable for domain
+                    .style('stroke-width', '1px'); // Ensure visibility
             });
         }
         var xSubgroup = d3.scaleBand().domain(subgroups);
         if (subgroups.length > 1 && !this.isZoomedOut) {
+            // For grouped bar charts in zoom-in view, use full x.bandwidth() for subgroups
             xSubgroup.range([0, x.bandwidth()]);
         }
         else if (subgroups.length === 1 && !this.isZoomedOut) {
+            // For single-bar (non-grouped) charts in zoom-in view, set bar width to 100 (increased from 80)
             xSubgroup.range([0, 100]);
         }
         else if (this.chartConfiguration.isMultiChartGridLine == undefined) {
             xSubgroup.range([0, x.bandwidth()]);
         }
         else {
+            // used to make grouped bars with lesser width as we are not using padding for width
             xSubgroup.range([0, x.bandwidth()]);
         }
+        // if (this.chartConfiguration.isDrilldownChart) {
+        // }
         var color = d3
             .scaleOrdinal()
             .domain(subgroups)
             .range(Object.values(metaData.colors));
+        // var colorAboveTarget = d3
+        //   .scaleOrdinal()
+        //   .domain(subgroups)
+        //   .range(Object.values(metaData.colorAboveTarget));
         var state = svg
             .append('g')
             .selectAll('.state')
@@ -7926,8 +8353,10 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             .data(function (d) {
             let newList = [];
             subgroups.map(function (key) {
+                // if (key !== "group") {
                 let obj = { key: key, value: d[key], name: d.name };
                 newList.push(obj);
+                // }
             });
             return newList;
         })
@@ -7940,6 +8369,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                     !metaData.barWithoutClick.length ||
                     (!metaData.barWithoutClick.includes(d?.name) &&
                         !metaData.barWithoutClick.includes(d?.key)))
+                    // self.handleClick(d.data.name);
                     self.handleClick(d);
             }
         })
@@ -7950,6 +8380,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                         let keys = Object.keys(indiv).filter((temp, i) => i != 0);
                         tempScale = d3.scaleBand().domain(keys).range([0, x.bandwidth()]);
                         if (x.bandwidth() > 100) {
+                            // Increase bar width a bit in zoom-in view
                             let reducedBarWidth = 60;
                             if (!self.isZoomedOut) {
                                 reducedBarWidth = 30;
@@ -7991,19 +8422,23 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             return y(0);
         })
             .attr('width', function (d) {
+            // For grouped bar charts in zoom-in view, set bar width to 50 for maximum thickness
             if (subgroups.length > 1 && !self.isZoomedOut) {
                 return 50;
             }
+            // For single-bar (non-grouped) charts in zoom-in view, set bar width to 80
             if (subgroups.length === 1 && !self.isZoomedOut) {
                 return 80;
             }
             let tempScale = d3.scaleBand().domain([]).range([0, 0]);
+            // Default logic for other chart types
             if (self.chartConfiguration.isDrilldownChart) {
                 data.map((indiv) => {
                     if (indiv.name == d.name) {
                         let keys = Object.keys(indiv).filter((temp, i) => i != 0);
                         tempScale = d3.scaleBand().domain(keys).range([0, x.bandwidth()]);
                         if (x.bandwidth() > 100) {
+                            // Increase bar width a bit in zoom-in view
                             let reducedBarWidth = 60;
                             if (!self.isZoomedOut) {
                                 reducedBarWidth = 100;
@@ -8071,6 +8506,9 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             }
             return self.chartData.metaData.colors[d.key];
         });
+        /**
+         * display angled texts on the bars
+         */
         if (this.chartConfiguration.textsOnBar != undefined && !this.isZoomedOut) {
             state
                 .selectAll('text')
@@ -8105,7 +8543,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 .style('font-weight', 'bold')
                 .style('font-size', function (d) {
                 if (self.isZoomedOut) {
-                    return '9px';
+                    return '9px'; // 👈 Zoomed out mode
                 }
                 if (self.chartConfiguration.isDrilldownChart) {
                     if (window.innerWidth > 1900) {
@@ -8135,12 +8573,14 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                                         0 + (x.bandwidth() - 200) / 2,
                                         x.bandwidth() - (x.bandwidth() - 200) / 2,
                                     ]);
+                                    // .padding(0.05);
                                 }
                                 else
                                     tempScale.range([
                                         0 + (x.bandwidth() - 300) / 2,
                                         x.bandwidth() - (x.bandwidth() - 300) / 2,
                                     ]);
+                                // .padding(0.05);
                             }
                             else
                                 tempScale.range([
@@ -8150,9 +8590,16 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                         }
                     }
                 });
+                /**
+                 * if set, then all texts ll be horizontal
+                 */
                 if (self.chartConfiguration.textAlwaysHorizontal) {
                     return ('translate(' + xSubgroup(d.key) + ',' + (y(d.value) - 3) + ')');
                 }
+                /**
+                 * rotate texts having more than one digits
+                 */
+                // if (d.value > 9)
                 if (!isNaN(tempScale(d.key)))
                     return ('translate(' +
                         (tempScale(d.key) + tempScale.bandwidth() * 0.55) +
@@ -8160,6 +8607,14 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                         (y(0) - 10) +
                         ') rotate(270)');
                 return 'translate(0,0)';
+                // else
+                //   return (
+                //     'translate(' +
+                //     (tempScale(d.key) + tempScale.bandwidth() / 2) +
+                //     ',' +
+                //     y(0) +
+                //     ')'
+                //   );
             })
                 .on('click', function (d) {
                 if (!metaData.barWithoutClick ||
@@ -8189,6 +8644,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             svg
                 .append('foreignObject')
                 .attr('x', function () {
+                // ...existing code for tempScale calculation...
                 var elementsCounter;
                 data.map((indiv) => {
                     if (indiv.name == d.name) {
@@ -8297,7 +8753,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             .append('g')
             .attr('class', 'x2 axis2')
             .attr('transform', 'translate(0,' + height + ')')
-            .style('color', 'var(--chart-axis-color, #000)')
+            .style('color', 'var(--chart-axis-color, #000)') // Use CSS variable instead of hardcoded #000
             .call(d3.axisBottom(xScaleFromOrigin).tickSize(0))
             .call((g) => g.select('.domain').attr('fill', 'none'));
         svg.selectAll('g.x2.axis2 g.tick text').style('display', 'none');
@@ -8325,6 +8781,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             return formatted >= 1000 ? formatted / 1000 + 'k' : formatted;
         }))
             .call((g) => {
+            // Style the domain line for theme support
             g.select('.domain')
                 .style('stroke', 'var(--chart-domain-color, #000000)')
                 .style('stroke-width', '1px');
@@ -8338,23 +8795,40 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             .attr('transform', 'translate(0,0)')
             .call(y)
             .style('display', 'none');
+        /**
+         * hide x axis labels
+         * config is there for future use
+         * used by weekly charts
+         */
         if (this.chartConfiguration.isXaxisLabelHidden != undefined &&
             this.chartConfiguration.isXaxisLabelHidden) {
             d3.selectAll('g.lib-line-x-axis-text > g > text').attr('class', 'lib-display-hidden');
         }
+        /**
+         * hide y axis labels
+         * used by weekly charts
+         */
         if (this.chartConfiguration.isYaxisLabelHidden != undefined &&
             this.chartConfiguration.isYaxisLabelHidden) {
             d3.selectAll('.yaxis-dashed > g > text').attr('class', 'lib-display-hidden');
         }
+        /**
+         * hide y axis labels
+         * config is there for future use
+         */
         if (this.chartConfiguration.isYaxisHidden != undefined &&
             this.chartConfiguration.isYaxisHidden) {
             d3.selectAll('.yaxis-dashed').attr('class', 'lib-display-hidden');
         }
+        /**
+         * dashed y axis
+         * used by weekly charts
+         */
         if (this.chartConfiguration.isYaxisDashed != undefined &&
             this.chartConfiguration.isYaxisDashed) {
             d3.selectAll('.yaxis-dashed')
                 .style('stroke-dasharray', '5 5')
-                .style('color', 'var(--chart-axis-color, #999999)');
+                .style('color', 'var(--chart-axis-color, #999999)'); // Use CSS variable
         }
         if (lineData != null) {
             if (lineData && self.chartConfiguration.showLineChartAxis) {
@@ -8366,12 +8840,28 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                     .call(yLineAxis);
             }
         }
+        /**
+         * used to display y label
+         */
+        // if (this.isZoomedOut) {
+        //   svg
+        //     .selectAll('.lib-xaxis-labels-texts-drilldown')
+        //     .attr('class', 'lib-display-hidden');
+        // }
         if (this.isZoomedOut) {
+            // svg
+            //   .selectAll('.lib-xaxis-labels-texts-drilldown')
+            //   .attr('transform', 'rotate(-30)')
+            //   .attr('text-anchor', 'end')
+            //   .attr('x', '-5')
+            //   .attr('dy', null)
+            //   .style('fill', 'var(--chart-text-color)');
             svg
                 .selectAll('.lib-xaxis-labels-texts-drilldown')
                 .each((d, i, nodes) => {
                 const text = d3.select(nodes[i]);
                 const label = text.text();
+                // If label contains \n, split and use tspan for each line
                 if (label.indexOf('\n') > -1) {
                     const lines = label.split('\n');
                     text.text(null);
@@ -8383,6 +8873,7 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                     });
                 }
                 else {
+                    // Fallback: split by space for other labels
                     const words = label.split(' ');
                     text.text(null);
                     words.forEach((word, index) => {
@@ -8391,11 +8882,15 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 }
             })
                 .style('fill', 'var(--chart-text-color)')
-                .attr('transform', null);
+                .attr('transform', null); // Remove rotate if using line breaks
+            // Optional: Adjust bottom margin or chart layout
             svg
                 .select('.x-axis')
                 .attr('transform', `translate(0, ${height - margin.bottom + 10})`);
         }
+        /**
+         * used to write y labels based on configuration
+         */
         if (metaData.yLabel) {
             const yPosition = isria ? 0 - margin.left / 2 - 30 : 0 - margin.left / 2 - 40;
             svgYAxisLeft
@@ -8431,6 +8926,13 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
                 .attr('y2', yZero)
                 .style('stroke-dasharray', '5 5')
                 .style('stroke', this.chartData.targetLineData.color);
+            // svgYAxisRight
+            //   .append('line')
+            //   .attr('x1', 0)
+            //   .attr('x2', rightSvgWidth)
+            //   .attr('y1', yZero)
+            //   .attr('y2', yZero)
+            //   .style('stroke', this.chartData.targetLineData.color);
             svgYAxisRight
                 .append('foreignObject')
                 .attr('transform', 'translate(' + 0 + ',' + (yZero - 30) + ')')
@@ -8458,6 +8960,13 @@ class HorizontalGroupedBarWithScrollZoomComponent extends ComponentUniqueId {
             });
         }
         if (this.chartConfiguration.isDrilldownChart) {
+            /**
+             * used by drilldown charts
+             */
+            // svg
+            //   .selectAll('.lib-axis-group-label')
+            //   .attr('class', 'lib-ylabel-drilldowncharts')
+            //   .text(metaData.yLabel.toLowerCase());
             svg.selectAll('g.x1.axis1 g.tick line').style('display', 'none');
         }
         if (metaData.xLabel) {