pace-chart-lib 1.0.18 → 1.0.20

package/dist/pace-chart-lib.es.js

@@ -11434,81 +11434,73 @@ const chartMargins = {
   bottom: 0,
   left: 0
 };
-var actualChartTypes = /* @__PURE__ */ ((actualChartTypes2) => {
-  actualChartTypes2["waterfall"] = "Waterfall";
-  actualChartTypes2["lineWithMarker"] = "LineWithMarker";
-  actualChartTypes2["stackLine"] = "StackLine";
-  actualChartTypes2["stackLine100"] = "100StackLine";
-  actualChartTypes2["line"] = "Line";
-  actualChartTypes2["bar"] = "Bar";
-  actualChartTypes2["stackColumn"] = "StackColumn";
-  actualChartTypes2["area"] = "Area";
-  actualChartTypes2["pie"] = "Pie";
-  actualChartTypes2["sankey"] = "Sankey";
-  actualChartTypes2["sunburst"] = "Sunburst";
-  actualChartTypes2["horizontalBar"] = "HorizontalBar";
-  actualChartTypes2["stackArea"] = "StackArea";
-  actualChartTypes2["stackArea100"] = "100StackArea";
-  actualChartTypes2["treeMap"] = "TreeMap";
-  actualChartTypes2["stackBar"] = "StackBar";
-  actualChartTypes2["stackColumn100"] = "100StackColumn";
-  actualChartTypes2["stackBar100"] = "100StackBar";
-  actualChartTypes2["scatterPlot"] = "ScatterPlot";
-  actualChartTypes2["customColumnChart"] = "CustomColumnChart";
-  actualChartTypes2["customBarChart"] = "CustomBarChart";
-  actualChartTypes2["histogram"] = "Histogram";
-  actualChartTypes2["columnHistogram"] = "ColumnHistogram";
-  actualChartTypes2["barHistogram"] = "BarHistogram";
-  actualChartTypes2["column"] = "Column";
-  actualChartTypes2["miscellaneous"] = "Miscellaneous";
-  actualChartTypes2["custom"] = "Custom";
-  actualChartTypes2["collapsableTree"] = "CollapsableTree";
-  actualChartTypes2["maps"] = "Maps";
-  actualChartTypes2["tornadoChart"] = "Tornado";
-  actualChartTypes2["pieOfPie"] = "PieOfPie";
-  actualChartTypes2["wordCloud"] = "WordCloud";
-  actualChartTypes2["boxPlot"] = "BoxPlot";
-  actualChartTypes2["bubblePlot"] = "BubblePlot";
-  actualChartTypes2["vennDiagramChart"] = "VennDiagramChart";
-  actualChartTypes2["speedometerChart"] = "SpeedometerChart";
-  actualChartTypes2["layeredColumnChart"] = "LayeredColumnChart";
-  actualChartTypes2["layeredBarChart"] = "LayeredBarChart";
-  actualChartTypes2["organizationalChart"] = "OrganizationalChart";
-  actualChartTypes2["pyramidChart"] = "PyramidChart";
-  actualChartTypes2["scaleBreakStackedColumnChart"] = "ScaleBreakStackedColumnChart";
-  actualChartTypes2["progressChart"] = "ProgressChart";
-  actualChartTypes2["radialBarChart"] = "RadialBarChart";
-  return actualChartTypes2;
-})(actualChartTypes || {});
+var chartTypes = /* @__PURE__ */ ((chartTypes2) => {
+  chartTypes2["WaterfallChart"] = "WaterfallChart";
+  chartTypes2["StackLineChart"] = "StackLineChart";
+  chartTypes2["NormalizedStackLineChart"] = "NormalizedStackLineChart";
+  chartTypes2["LineChart"] = "LineChart";
+  chartTypes2["ColumnChart"] = "ColumnChart";
+  chartTypes2["StackColumnChart"] = "StackColumnChart";
+  chartTypes2["AreaChart"] = "AreaChart";
+  chartTypes2["PieChart"] = "PieChart";
+  chartTypes2["SankeyChart"] = "SankeyChart";
+  chartTypes2["DonutChart"] = "DonutChart";
+  chartTypes2["HorizontalBarChart"] = "HorizontalBarChart";
+  chartTypes2["StackAreaChart"] = "StackAreaChart";
+  chartTypes2["NormalizedStackAreaChart"] = "NormalizedStackAreaChart";
+  chartTypes2["Treemap"] = "Treemap";
+  chartTypes2["StackHorizontalBarChart"] = "StackHorizontalBarChart";
+  chartTypes2["NormalizedStackColumnChart"] = "NormalizedStackColumnChart";
+  chartTypes2["NormalizedStackHorizontalBarChart"] = "NormalizedStackHorizontalBarChart";
+  chartTypes2["ScatterChart"] = "ScatterChart";
+  chartTypes2["CustomColumnChart"] = "CustomColumnChart";
+  chartTypes2["customBarChart"] = "CustomBarChart";
+  chartTypes2["ColumnHistogramChart"] = "ColumnHistogramChart";
+  chartTypes2["HorizontalHistogramChart"] = "HorizontalHistogramChart";
+  chartTypes2["Maps"] = "Maps";
+  chartTypes2["TornadoChart"] = "TornadoChart";
+  chartTypes2["PieofPie"] = "PieofPie";
+  chartTypes2["WordCloud"] = "WordCloud";
+  chartTypes2["BubbleChart"] = "BubbleChart";
+  chartTypes2["VennChart"] = "VennChart";
+  chartTypes2["Speedometer"] = "Speedometer";
+  chartTypes2["LayeredColumnChart"] = "LayeredColumnChart";
+  chartTypes2["LayeredHorizontalBarChart"] = "LayeredHorizontalBarChart";
+  chartTypes2["OrganizationChart"] = "OrganizationChart";
+  chartTypes2["PyramidChart"] = "PyramidChart";
+  chartTypes2["ProgressChart"] = "ProgressChart";
+  chartTypes2["RadialBarChart"] = "RadialBarChart";
+  return chartTypes2;
+})(chartTypes || {});
 const connecterCurve = {
   1: "",
   2: curveLinear$1,
   3: step
 };
 const chartsWithDataTableArray = [
-  actualChartTypes.bar,
-  actualChartTypes.stackColumn,
-  actualChartTypes.stackColumn100,
-  actualChartTypes.line,
-  actualChartTypes.stackLine,
-  actualChartTypes.stackLine100,
-  actualChartTypes.area,
-  actualChartTypes.stackArea,
-  actualChartTypes.stackArea100
+  chartTypes.ColumnChart,
+  chartTypes.StackColumnChart,
+  chartTypes.NormalizedStackColumnChart,
+  chartTypes.LineChart,
+  chartTypes.StackLineChart,
+  chartTypes.NormalizedStackLineChart,
+  chartTypes.AreaChart,
+  chartTypes.StackAreaChart,
+  chartTypes.NormalizedStackAreaChart
 ];
 const chartsWithoutPlotArea = [
-  actualChartTypes.pie,
-  actualChartTypes.pieOfPie,
-  actualChartTypes.sunburst,
-  actualChartTypes.pyramidChart,
-  actualChartTypes.organizationalChart,
-  actualChartTypes.vennDiagramChart,
-  actualChartTypes.progressChart,
-  actualChartTypes.maps,
-  actualChartTypes.wordCloud,
-  actualChartTypes.sankey,
-  actualChartTypes.speedometerChart,
-  actualChartTypes.radialBarChart
+  chartTypes.PieChart,
+  chartTypes.PieofPie,
+  chartTypes.DonutChart,
+  chartTypes.PyramidChart,
+  chartTypes.OrganizationChart,
+  chartTypes.VennChart,
+  chartTypes.ProgressChart,
+  chartTypes.Maps,
+  chartTypes.WordCloud,
+  chartTypes.SankeyChart,
+  chartTypes.Speedometer,
+  chartTypes.RadialBarChart
 ];
 function calculateWidthHeightDynamically(content, fontSize, fontFamily, rotationDegree, fixedWidth) {
   var div = document.createElement("div");
@@ -11882,7 +11874,7 @@ function initSvg$1(svg, width, height, formatOptions) {
   if (chartAreaBorder) {
     const borderColor = formatOptions.chartArea.chartAreaBorderColor;
     const borderWidth = formatOptions.chartArea.chartAreaBorderThickness;
-    const borderStyle = formatOptions.chartArea.chartAreaBorderStyle;
+    const borderStyle = formatOptions.chartArea.chartAreaBorderStyle.toString();
     const border = borderStyle === "1" ? "solid" : borderStyle === "2" ? "dashed" : "dotted";
     svg.style("outline", `${borderWidth}px ${border} ${borderColor}`).style("outline-offset", `-${borderWidth}px`);
   } else {
@@ -12268,6 +12260,28 @@ function responsiveYaxisLabel$1(Ymax, Ymin, innerHeight2, formatOptions, chartJS
     );
     let yAxisLabelArray = [];
     let customTickValue;
+    const isTornadoChart = Ymin < 0 && Ymax > 0;
+    if (isTornadoChart) {
+      const maxAbs = Math.max(Math.abs(Ymin), Math.abs(Ymax));
+      const finalMax = customYaxisMaxValue || maxAbs;
+      const finalMin = customYaxisMinValue || -finalMax;
+      if (customYaxisIntervalValue && customYaxisIntervalValue > 0) {
+        for (let v = finalMin; v <= finalMax + 1e-6; v += customYaxisIntervalValue) {
+          yAxisLabelArray.push(parseFloat(v.toFixed(6)));
+        }
+        customTickValue = yAxisLabelArray.length;
+      } else {
+        autoLabelFlag = true;
+        const tickCount = 6;
+        for (let i = -tickCount; i <= tickCount; i++) {
+          yAxisLabelArray.push(
+            parseFloat((i * finalMax / tickCount).toFixed(6))
+          );
+        }
+        customTickValue = barChart ? innerWidth2 / 80 : innerHeight2 / 80;
+      }
+      return { yAxisLabelArray, customTickValue, autoLabelFlag };
+    }
     if (!customYaxisMaxValue && Ymax > 0) {
       const range2 = Ymax - Ymin;
       const padding = range2 * 0.05;
@@ -12479,14 +12493,14 @@ function responsiveXaxisLabel(dimensionList, innerWidth2) {
 }
 function initXaxis$1(gTag, chartJSON, xLabel, formatOptions, dataTableHeight, yScaleLeft, xAxis, dimensionHeightWidthArray, height, barWidth, isDateType, innerWidth2, innerHeight2, filteredDimensionList) {
   try {
-    let responsiveDimList = chartJSON.chartType !== actualChartTypes.columnHistogram ? responsiveXaxisLabel(
+    let responsiveDimList = chartJSON.chartType !== chartTypes.ColumnHistogramChart ? responsiveXaxisLabel(
       filteredDimensionList,
       innerWidth2
     ) : [];
     let formatedResponsiveDimList = [];
     let actualDimesionWidth = dimensionHeightWidthArray[0] + 5;
     let maxDimensionWidth = dimensionHeightWidthArray[3] + 10;
-    if (chartJSON.chartType != actualChartTypes.waterfall && chartJSON.chartType != actualChartTypes.columnHistogram) {
+    if (chartJSON.chartType != chartTypes.WaterfallChart && chartJSON.chartType != chartTypes.ColumnHistogramChart) {
       formatedResponsiveDimList = isDateType ? setDateFormats(
         formatOptions.xAxisLabel.xAxisNumberFormat,
         responsiveDimList.map((d) => d)
@@ -12545,7 +12559,7 @@ function initXaxis$1(gTag, chartJSON, xLabel, formatOptions, dataTableHeight, yS
       "visibility",
       formatOptions.xAxisLabel.xAxisLabelVisibility ? "visible" : "hidden"
     );
-    if (chartJSON.chartType === actualChartTypes.columnHistogram) {
+    if (chartJSON.chartType === chartTypes.ColumnHistogramChart) {
       xLabelsObj.attr("title", (d, i) => getNumberWithFormat(d, formatOptions.xAxisLabel.xAxisDisplayUnits, formatOptions.xAxisLabel.xAxisNumberFormat, formatOptions.xAxisLabel.xAxisLabelDecimalPrecision, false)).html((d, i) => getNumberWithFormat(d, formatOptions.xAxisLabel.xAxisDisplayUnits, formatOptions.xAxisLabel.xAxisNumberFormat, formatOptions.xAxisLabel.xAxisLabelDecimalPrecision, false));
     } else {
       xLabelsObj.attr("title", (d, i) => ("" + formatedResponsiveDimList[i]).trim()).html((d, i) => ("" + formatedResponsiveDimList[i]).trim());
@@ -12711,12 +12725,12 @@ function setXaxistitle$1(formatOptions, barChart, svg, margin, xLabel, height, x
       //             ? formatOptions?.xAxisLabel?.xAxisPosition == "1"
       //                 ? 0
       //                 : xLabel
-      //             : chartType == actualChartTypes.tornadoChart
+      //             : chartType == chartTypes.tornadoChart
       //                 ? xLabel + 5
       //                 : yLabel + 5)
       //         })`
       `translate(${margin.left},${margin.top + innerHeight2 + (formatOptions?.xAxisLabel?.xAxisPosition == "1" ? 0 : barChart ? yLabel : xLabel)})`
-      // `translate(${margin.left},${Margin.top + innerHeight + (chartsWithXScrollFlag ? (formatOptions?.xAxisLabel?.xAxisPosition == "1" ? 0 : Xlabel) : (attributes.type == ActualChartTypes.TornadoChart) ? Xlabel + 5 : yLabel + 5) })`
+      // `translate(${margin.left},${Margin.top + innerHeight + (chartsWithXScrollFlag ? (formatOptions?.xAxisLabel?.xAxisPosition == "1" ? 0 : Xlabel) : (attributes.type == chartTypes.TornadoChart) ? Xlabel + 5 : yLabel + 5) })`
     ).attr("class", "xAxisTitle").attr("width", innerWidth2).attr("height", xTitle + "px").style("z-index", "9999");
     if (formatOptions.xAxisTitle.xAxisDynamicTitleText.length !== 0) {
       object2.append("xhtml:div").style("color", "rgba(119,119,119)").attr("title", formatOptions.xAxisTitle.xAxisTitleText).style("white-space", "pre").style("text-overflow", "ellipsis").html(
@@ -12807,9 +12821,8 @@ function getCurveType(formatOptions) {
     return stepAfter;
   }
 }
-function commonAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin, d3Annotation2, labelExcludeList, individualLabelColor, oldAnnotationList, formatOptions, chartType, height, width, innerWidth2, dimensionList, innerHeight2, widgetId, svg, xScaleForLegends, columnWidth, isSensitivityChart, barChart) {
+function commonAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin, d3Annotation2, labelExcludeList, individualLabelColor, oldAnnotationList, formatOptions, chartType, height, width, innerWidth2, dimensionList, innerHeight2, widgetId, svg, xScaleForLegends, columnWidth, isReportEditable, isSensitivityChart, barChart) {
   try {
-    let fromReportBuilder = false;
     let annotationType = formatOptions.annotation.annotationType ?? "1";
     if (formatOptions.annotation.annotationVisibility) {
       let Disable = [annotationType == "1" ? "connector" : ""];
@@ -12970,12 +12983,12 @@ function commonAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin, d
         let singleAnnotation = {
           note: {
             label: d.Measure >= 1e9 && formatOptions.annotation.annotationNumberFormat === ".2s" ? Math.round(d.Measure / 1e9) + "B" : getNumberWithFormat(
-              chartType === actualChartTypes.tornadoChart ? Math.abs(d.Measure) : d.Measure,
+              chartType === chartTypes.TornadoChart ? Math.abs(d.Measure) : d.Measure,
               formatOptions.annotation.annotationDisplayUnits || formatOptions.plotArea.plotAreaDisplayUnits,
               formatOptions.annotation.annotationNumberFormat,
               formatOptions.annotation.annotationDecimalPrecision
             ),
-            align: barChart && chartType !== actualChartTypes.tornadoChart ? parseInt(d.LabelPosition) === 2 ? "middle" : "start" : chartType === actualChartTypes.tornadoChart ? "end" : "middle"
+            align: barChart && chartType !== chartTypes.TornadoChart ? parseInt(d.LabelPosition) === 2 ? "middle" : "start" : chartType === chartTypes.TornadoChart ? "end" : "middle"
           },
           data: barChart ? {
             y: d.Dimension,
@@ -13036,15 +13049,13 @@ function commonAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin, d
         }
         finalAnnotationList.push(newAnnotation);
       });
-      makeAnnotations.editMode(
-        formatOptions.annotation.annotationDraggable && !(fromReportBuilder == void 0 && widgetId != void 0)
-      ).accessors({
+      makeAnnotations.editMode(formatOptions.annotation.annotationDraggable && isReportEditable).accessors({
         x: function(d) {
           if (barChart) {
             let requiredXScale = d.x.axis === "Primary" ? yScaleLeft : yScaleRight;
             let axis2 = d.x.axis;
             return dataLabelsPositionForBarChartFamily(formatOptions, d.x.measure ? d.x.measure : 0, d.position, requiredXScale, minValue, void 0, chartType, isSensitivityChart, axis2);
-          } else if (chartType === actualChartTypes.column) {
+          } else if (chartType === chartTypes.ColumnChart) {
             return xScaleForLegends(d.currentLegend) ? xScale(d.x) + xScaleForLegends(d.currentLegend) - (columnWidth - xScaleForLegends.bandwidth()) / 2 : xScale(d.x);
           } else {
             return xScale(d.x);
@@ -13062,7 +13073,7 @@ function commonAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin, d
             );
           } else {
             if (barChart) {
-              let actualColWidth = chartType === actualChartTypes.tornadoChart || chartType === actualChartTypes.layeredBarChart ? xScaleForLegends.bandwidth() : -columnWidth;
+              let actualColWidth = chartType === chartTypes.TornadoChart || chartType === chartTypes.LayeredHorizontalBarChart ? xScaleForLegends.bandwidth() : -columnWidth;
               return (xScaleForLegends && xScaleForLegends(d.currentLegend) ? xScaleForLegends(d.currentLegend) + xScaleForLegends.bandwidth() / 2 : 0) + xScale(d.y) - 5;
             } else
               return dataLabelsPosition(
@@ -13108,7 +13119,7 @@ function commonAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin, d
         ).filter((d) => d._dx == 0 && d._dy == 0).remove();
         annotations.selectAll(".annotation-note-label").filter((d) => d.data && d.data.isVisible).style("display", "block");
       }).on("noteclick", function(annotation2) {
-        if (formatOptions.annotation.annotationDraggable && !(fromReportBuilder == void 0 && widgetId != void 0)) {
+        if (formatOptions.annotation.annotationDraggable && isReportEditable) {
           annotation2.data.isVisible = false;
           oldAnnotationList.forEach((d) => {
             if (d.data.x == annotation2.data.x && d.data.y.measure == annotation2.data.y.measure) {
@@ -13131,7 +13142,7 @@ function commonAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin, d
     throw error;
   }
 }
-function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRight, margin, d3Annotation2, stackColumnData, stackAreaData, labelExcludeList, individualLabelColor, columnWidth, oldAnnotationList, formatOptions, height, width, innerWidth2, dimensionList, innerHeight2, widgetId, svg, xScaleForLegends) {
+function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRight, margin, d3Annotation2, stackColumnData, stackAreaData, labelExcludeList, individualLabelColor, columnWidth, oldAnnotationList, formatOptions, height, width, innerWidth2, dimensionList, innerHeight2, widgetId, svg, xScaleForLegends, isReportEditable) {
   try {
     let annotationType = formatOptions.annotation.annotationType ?? "1";
     if (formatOptions.annotation.annotationVisibility) {
@@ -13144,7 +13155,7 @@ function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRi
       let stackData = [];
       let getChartType = [];
       let connectorType = formatOptions.annotation.connectorType ? formatOptions.annotation.connectorType.toLowerCase() : "None";
-      oldAnnotationList = conditionallyResetOldAnnotations(oldAnnotationList, formatOptions, actualChartTypes.customColumnChart);
+      oldAnnotationList = conditionallyResetOldAnnotations(oldAnnotationList, formatOptions, chartTypes.CustomColumnChart);
       let annotationsList = [];
       let finalAnnotationList = [];
       if (oldAnnotationList.length != 0) {
@@ -13165,15 +13176,15 @@ function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRi
         case "2":
           chartData.forEach((d, i) => {
             switch (d.properties.type) {
-              case actualChartTypes.column:
-              case actualChartTypes.line:
-              case actualChartTypes.area:
+              case chartTypes.ColumnChart:
+              case chartTypes.LineChart:
+              case chartTypes.AreaChart:
                 labelData.push(d.data[0]);
                 break;
-              case actualChartTypes.stackColumn:
+              case chartTypes.StackColumnChart:
                 stackColumnData.forEach((dta) => labelData.push(dta[0]));
                 break;
-              case actualChartTypes.stackArea:
+              case chartTypes.StackAreaChart:
                 stackAreaData.forEach((dta) => labelData.push(dta[0]));
                 break;
             }
@@ -13182,17 +13193,17 @@ function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRi
         case "3":
           chartData.forEach((d) => {
             switch (d.properties.type) {
-              case actualChartTypes.column:
-              case actualChartTypes.line:
-              case actualChartTypes.area:
+              case chartTypes.ColumnChart:
+              case chartTypes.LineChart:
+              case chartTypes.AreaChart:
                 labelData.push(d.data[d.data.length - 1]);
                 break;
-              case actualChartTypes.stackColumn:
+              case chartTypes.StackColumnChart:
                 stackColumnData.forEach(
                   (dta) => labelData.push(dta[dta.length - 1])
                 );
                 break;
-              case actualChartTypes.stackArea:
+              case chartTypes.StackAreaChart:
                 stackAreaData.forEach(
                   (dta) => labelData.push(dta[dta.length - 1])
                 );
@@ -13203,34 +13214,34 @@ function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRi
         case "4":
           chartData.forEach((d, i) => {
             switch (d.properties.type) {
-              case actualChartTypes.column:
-              case actualChartTypes.line:
-              case actualChartTypes.area:
+              case chartTypes.ColumnChart:
+              case chartTypes.LineChart:
+              case chartTypes.AreaChart:
                 labelData.push(d.data[0]);
                 break;
-              case actualChartTypes.stackColumn:
+              case chartTypes.StackColumnChart:
                 stackColumnData.forEach((dta) => labelData.push(dta[0]));
                 break;
-              case actualChartTypes.stackArea:
+              case chartTypes.StackAreaChart:
                 stackAreaData.forEach((dta) => labelData.push(dta[0]));
                 break;
             }
           });
           chartData.forEach((d) => {
             switch (d.properties.type) {
-              case actualChartTypes.column:
-              case actualChartTypes.line:
-              case actualChartTypes.area:
+              case chartTypes.ColumnChart:
+              case chartTypes.LineChart:
+              case chartTypes.AreaChart:
                 labelData.push(
                   d.data[d.data.length - 1]
                 );
                 break;
-              case actualChartTypes.stackColumn:
+              case chartTypes.StackColumnChart:
                 stackColumnData.forEach(
                   (dta) => labelData.push(dta[dta.length - 1])
                 );
                 break;
-              case actualChartTypes.stackArea:
+              case chartTypes.StackAreaChart:
                 stackAreaData.forEach(
                   (dta) => labelData.push(dta[dta.length - 1])
                 );
@@ -13241,18 +13252,18 @@ function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRi
         case "1":
           chartData.forEach((d) => {
             switch (d.properties.type) {
-              case actualChartTypes.column:
-              case actualChartTypes.line:
-              case actualChartTypes.area:
+              case chartTypes.ColumnChart:
+              case chartTypes.LineChart:
+              case chartTypes.AreaChart:
                 d.data.forEach((j) => labelData.push(j));
                 break;
-              case actualChartTypes.stackColumn:
+              case chartTypes.StackColumnChart:
                 let stackColumnIndex = stackColumnData.findIndex((id2) => id2.key === d.properties.legend);
                 if (stackColumnIndex !== -1) {
                   stackColumnData[stackColumnIndex].forEach((dta) => labelData.push(dta));
                 }
                 break;
-              case actualChartTypes.stackArea:
+              case chartTypes.StackAreaChart:
                 let stackAreaIndex = stackAreaData.findIndex((id2) => id2.key === d.properties.legend);
                 if (stackAreaIndex !== -1) {
                   stackAreaData[stackAreaIndex].forEach((dta) => labelData.push(dta));
@@ -13294,7 +13305,7 @@ function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRi
           },
           data: {
             x: d.dimension && d.legend ? { dimension: d.dimension, legend: d.legend, type: d.type, axis: d.axis || d.data.axis } : { dimension: d.data.dimension, legend: d.key, type: d.data.type, stacklegend: d.data.legend, axis: d.data.axis },
-            y: d.value || d.value == 0 ? d.value : d.data.type != actualChartTypes.stackColumn ? d[1] ? d[1] : 0 : d[1] > 0 ? d[1] : d[0],
+            y: d.value || d.value == 0 ? d.value : d.data.type != chartTypes.StackColumnChart ? d[1] ? d[1] : 0 : d[1] > 0 ? d[1] : d[0],
             prevValue: d[0] >= 0 ? d[0] : d[1],
             position: parseInt(d.labelPosition) ? parseInt(d.labelPosition) : parseInt(d.data.labelPosition),
             type: d.dimension && d.legend ? d.type : d.data.type,
@@ -13346,10 +13357,7 @@ function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRi
         }
         finalAnnotationList.push(newAnnotation);
       });
-      makeAnnotations.editMode(
-        formatOptions.annotation.annotationDraggable
-        // && (!(self.attributes.fromReportBuilder == undefined && this.svgIndex != undefined))
-      ).accessors({
+      makeAnnotations.editMode(formatOptions.annotation.annotationDraggable && isReportEditable).accessors({
         x: function(d) {
           if (getChartType.includes(d.x.type) || getChartType.includes(d.type)) {
             let chartType = d.x.type || d.type;
@@ -13400,7 +13408,7 @@ function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRi
         annotations.selectAll(".note-line").attr("hoverId", (d) => d.data.currentLegend).style("stroke", formatOptions.annotation.connectorColor || "#ccc").attr("stroke-dasharray", connectedStyle[formatOptions.annotation.connectorStyle]).filter((d) => d._dx == 0 && d._dy == 0).remove();
         annotations.selectAll(".annotation-note-label").filter((d) => d.data && d.data.isVisible).style("display", "block");
       }).on("noteclick", function(annotation2) {
-        if (formatOptions.annotation.annotationDraggable) {
+        if (formatOptions.annotation.annotationDraggable && isReportEditable) {
           annotation2.data.isVisible = false;
           oldAnnotationList.forEach((d) => {
             if (d.data.x.dimension == annotation2.data.x.dimension && d.data.x.legend == annotation2.data.x.legend && d.data.x.type == annotation2.data.x.type && d.data.prevValue == annotation2.data.prevValue) {
@@ -13424,8 +13432,8 @@ function commonAnnotationsForCustomChart(chartData, xScale, yScaleLeft, yScaleRi
 const conditionallyResetOldAnnotations = (oldAnnotationList, formatOptions, chartType) => {
   try {
     let path2 = [
-      actualChartTypes.pie,
-      actualChartTypes.sunburst
+      chartTypes.PieChart,
+      chartTypes.DonutChart
     ].includes(chartType) ? "plotArea" : "annotation";
     const isDraggable = formatOptions[path2].annotationDraggable;
     const isMeasureReplaced = false;
@@ -13452,28 +13460,28 @@ const annotationTypeforCharts = (d3Annotation2, type) => {
 };
 const dataLabelsPosition = (yCordinate, position, yScale, minValue, prevValue, chartType) => {
   try {
-    let allStackCharts = [actualChartTypes.line, actualChartTypes.stackLine, actualChartTypes.stackArea, actualChartTypes.stackArea100, actualChartTypes.stackLine100, actualChartTypes.stackArea];
+    let allStackCharts = [chartTypes.LineChart, chartTypes.StackLineChart, chartTypes.StackAreaChart, chartTypes.NormalizedStackAreaChart, chartTypes.NormalizedStackLineChart, chartTypes.StackAreaChart];
     prevValue ? prevValue : prevValue = 0;
     switch (position) {
       case 1:
         let yOffset;
         switch (chartType) {
-          case actualChartTypes.line:
-          case actualChartTypes.bar:
-          case actualChartTypes.column:
-          case actualChartTypes.area:
-          case actualChartTypes.stackArea:
+          case chartTypes.LineChart:
+          case chartTypes.HorizontalBarChart:
+          case chartTypes.ColumnChart:
+          case chartTypes.AreaChart:
+          case chartTypes.StackAreaChart:
             yOffset = yCordinate < 0 ? yScale(yCordinate) + 7 : yScale(yCordinate) - 15;
             break;
-          case actualChartTypes.stackBar:
-          case actualChartTypes.stackLine100:
-          case actualChartTypes.stackLine:
-          case actualChartTypes.stackArea100:
-          case actualChartTypes.stackArea:
-          case actualChartTypes.stackColumn:
+          case chartTypes.StackHorizontalBarChart:
+          case chartTypes.NormalizedStackLineChart:
+          case chartTypes.StackLineChart:
+          case chartTypes.NormalizedStackAreaChart:
+          case chartTypes.StackAreaChart:
+          case chartTypes.StackColumnChart:
             yOffset = yCordinate < 0 ? yScale(yCordinate) + 5 : yScale(yCordinate) - 15;
             break;
-          case actualChartTypes.tornadoChart:
+          case chartTypes.TornadoChart:
             yOffset = yScale(yCordinate) + yScale.bandwidth() / 2;
             break;
           default:
@@ -13550,19 +13558,19 @@ function addDataTable(isFitChart, svg, currentTag, dataTable, colWidth, yAxis, x
       let legendsParentTag = temp.append("foreignObject").attr("x", -margin.left).attr("y", tableStartY + yCordinate).attr("width", margin.left).attr("height", cellHeight2);
       let innerdiv = legendsParentTag.append("xhtml:div").style("display", "flex").style("justify-content", "flex-start").style("align-items", "center").attr("class", "parentClass").style("flex-wrap", "nowrap").style("pointer-events", "auto").style("width", cellWidth).style("height", `${cellHeight2}px`).style("padding-left", `5px`).style("padding-right", `3px`).style("border-width", getBorderStyle(formatOptions, i, void 0, dimensionCount, legendsCount, "width")).style("border-style", getBorderStyle(formatOptions, i, void 0, dimensionCount, legendsCount, "style")).style("border-color", getBorderStyle(formatOptions, i, void 0, dimensionCount, legendsCount, "color"));
       switch (chartType) {
-        case actualChartTypes.column:
-        case actualChartTypes.stackColumn:
-        case actualChartTypes.stackColumn100:
+        case chartTypes.ColumnChart:
+        case chartTypes.StackColumnChart:
+        case chartTypes.NormalizedStackColumnChart:
           innerdiv.append("xhtml:div").style("height", "10px").style("width", "15px").style("background", data.properties.color).style("border-radius", "1px");
           break;
-        case actualChartTypes.line:
-        case actualChartTypes.stackLine:
-        case actualChartTypes.stackLine100:
+        case chartTypes.LineChart:
+        case chartTypes.StackLineChart:
+        case chartTypes.NormalizedStackLineChart:
           getLineShape(data, innerdiv, formatOptions);
           break;
-        case actualChartTypes.area:
-        case actualChartTypes.stackArea:
-        case actualChartTypes.stackArea100:
+        case chartTypes.AreaChart:
+        case chartTypes.StackAreaChart:
+        case chartTypes.NormalizedStackAreaChart:
           getAreaShape(data, innerdiv, formatOptions);
           break;
       }
@@ -13589,7 +13597,7 @@ function addDataTable(isFitChart, svg, currentTag, dataTable, colWidth, yAxis, x
     let cellHeight = 20;
     let yCordinate = 0;
     let calWidthForSeriesNames = calculatedRange[0] ? calculatedRange[0] : 0;
-    let isNormalizedChart = chartType == actualChartTypes.stackColumn100 || chartType == actualChartTypes.stackLine100 || chartType == actualChartTypes.stackArea100;
+    let isNormalizedChart = chartType == chartTypes.NormalizedStackColumnChart || chartType == chartTypes.NormalizedStackLineChart || chartType == chartTypes.NormalizedStackAreaChart;
     let outerPadding = 2;
     let fontStyle = formatOptions.dataTableProperties.dataTableFontStyle;
     let legendStringMaxLength = 0;
@@ -14369,7 +14377,7 @@ function prepareDataForSeriesLabel(innerWidth2, yScaleLeft, formatOptions, filte
     throw error;
   }
 }
-function stacklineAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin, d3Annotation2, labelExcludeList, individualLabelColor, oldAnnotationList, formatOptions, chartType, height, width, innerWidth2, dimensionList, innerHeight2, widgetId, svg, dataTableHeight, barChart) {
+function stacklineAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin, d3Annotation2, labelExcludeList, individualLabelColor, oldAnnotationList, formatOptions, chartType, height, width, innerWidth2, dimensionList, innerHeight2, widgetId, svg, dataTableHeight, isReportEditable, barChart) {
   try {
     let fromReportBuilder = false;
     let annotationType = formatOptions.annotation.annotationType ?? "1";
@@ -14514,7 +14522,7 @@ function stacklineAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin
         }
         finalAnnotationList.push(newAnnotation);
       });
-      makeAnnotations.editMode(formatOptions.annotation.annotationDraggable && !(fromReportBuilder == void 0 && widgetId != void 0)).accessors({
+      makeAnnotations.editMode(formatOptions.annotation.annotationDraggable && isReportEditable).accessors({
         x: function(d) {
           if (barChart) {
             return dataLabelsPositionForBarChartFamily(formatOptions, d.x, parseFloat(d.position), yScaleLeft, minValue, d.prevValue, chartType);
@@ -14552,7 +14560,7 @@ function stacklineAnnotations(chartData, xScale, yScaleLeft, yScaleRight, margin
         annotations.selectAll(".note-line").attr("hoverId", (d) => d.data.currentLegend).style("stroke", formatOptions.annotation.connectorColor || "#ccc").filter((d) => d._dx == 0 && d._dy == 0).remove();
         annotations.selectAll(".annotation-note-label").filter((d) => d.data && d.data.isVisible).style("display", "block");
       }).on("noteclick", function(annotation2) {
-        if (formatOptions.annotation.annotationDraggable) {
+        if (formatOptions.annotation.annotationDraggable && isReportEditable) {
           annotation2.data.isVisible = false;
           oldAnnotationList.forEach((d) => {
             if (d.data.x == annotation2.data.x && d.data.y == annotation2.data.y) {
@@ -14640,12 +14648,12 @@ const initYaxisBar = (formatOptions, gTag, xLabel, innerHeight2, innerWidth2, yA
     ).map((d) => d) : responsiveDimList;
     gTag.selectAll("#yAxisRect").remove();
     gTag.selectAll("#yAxisG").remove();
-    let yRect = gTag.append("rect").attr("id", "yAxisRect").attr("transform", chartType === actualChartTypes.tornadoChart ? `translate(${-xLabelMargin - 20},0)` : `translate(${xaxisLabelPosition === 0 ? -xLabelMargin - 5 : xaxisLabelPosition === 1 ? innerWidth2 : xScaleBottom(0) + (-xLabelMargin - 5)},0)`).attr("height", innerHeight2).attr("width", chartType === actualChartTypes.tornadoChart ? xLabelMargin + 20 : xLabelMargin + 5).attr(
+    let yRect = gTag.append("rect").attr("id", "yAxisRect").attr("transform", chartType === chartTypes.TornadoChart ? `translate(${-xLabelMargin - 20},0)` : `translate(${xaxisLabelPosition === 0 ? -xLabelMargin - 5 : xaxisLabelPosition === 1 ? innerWidth2 : xScaleBottom(0) + (-xLabelMargin - 5)},0)`).attr("height", innerHeight2).attr("width", chartType === chartTypes.TornadoChart ? xLabelMargin + 20 : xLabelMargin + 5).attr(
       "fill",
       formatOptions.xAxisLabel.xAxisLabelVisibility ? formatOptions.xAxisLabel.xAxisBackgroundColor ? formatOptions.xAxisLabel.xAxisBackgroundColor !== "#ffffff" ? formatOptions.xAxisLabel.xAxisBackgroundColor : "none" : formatOptions.chartArea.chartAreaColor : formatOptions.chartArea.chartAreaColor
     );
-    const YaxisG = gTag.append("g").attr("id", "yAxisG").attr("transform", chartType === actualChartTypes.tornadoChart ? `translate(${xScaleBottom(0)},0)` : `translate(${xaxisLabelPosition === 0 ? 0 : xaxisLabelPosition === 1 ? innerWidth2 : xScaleBottom(0)},0)`).call(yAxis);
-    if (chartType !== actualChartTypes.tornadoChart) {
+    const YaxisG = gTag.append("g").attr("id", "yAxisG").attr("transform", chartType === chartTypes.TornadoChart ? `translate(${xScaleBottom(0)},0)` : `translate(${xaxisLabelPosition === 0 ? 0 : xaxisLabelPosition === 1 ? innerWidth2 : xScaleBottom(0)},0)`).call(yAxis);
+    if (chartType !== chartTypes.TornadoChart) {
       let foreignObject = YaxisG.selectAll("g").append("foreignObject").attr("class", "testingoverflowing").attr("width", xLabelMargin).attr("height", "20px").attr(
         "transform",
         `rotate(${90 - formatOptions.xAxisLabel.xAxisLabelRotation})
@@ -14659,7 +14667,7 @@ const initYaxisBar = (formatOptions, gTag, xLabel, innerHeight2, innerWidth2, yA
         formatOptions.xAxisLabel.xAxisLabelVisibility ? "visible" : "hidden"
       ).attr("title", (d, i) => formatedResponsiveDimList[i]).html((d, i) => formatedResponsiveDimList[i]);
     }
-    if (chartType === actualChartTypes.tornadoChart) {
+    if (chartType === chartTypes.TornadoChart) {
       YaxisG.selectAll("text").attr("dx", `${-(xScaleBottom(yMaxLeft * 0.01) + 15)}px`).style("fill", formatOptions.xAxisLabel.xAxisLabelColor !== "#ffffff" ? formatOptions.xAxisLabel.xAxisLabelColor : "none").style("font-family", formatOptions.xAxisLabel.xAxisLabelFontFamily).style("color", formatOptions.xAxisLabel.xAxisLabelColor).style("font-size", formatOptions.xAxisLabel.xAxisLabelFontSize + "px").style("font-style", fontStyle.includes("Italic") ? "Italic" : "").style(
         "text-decoration",
         fontStyle.includes("Underline") ? "Underline" : ""
@@ -14667,15 +14675,17 @@ const initYaxisBar = (formatOptions, gTag, xLabel, innerHeight2, innerWidth2, yA
         "visibility",
         formatOptions.xAxisLabel.xAxisLabelVisibility ? "visible" : "hidden"
       ).attr("title", (d, i) => responsiveXaxisLabel(dimensionList, innerWidth2)[i]).html((d, i) => responsiveXaxisLabel(dimensionList, innerWidth2)[i]);
-      const YaxisRightG = gTag.append("g").attr("transform", `translate(${xScaleBottom(0)},0)`).call(xAxisTop);
-      YaxisRightG.selectAll("line").style("shape-rendering", "crispEdges").style("stroke", formatOptions.plotArea.gridLinesColor).attr(
-        "visibility",
-        formatOptions.xAxisLabel.xAxisLabelVisibility ? "visible" : formatOptions.plotArea.gridLinesVertical ? "visible" : "hidden"
-      );
-      YaxisRightG.select(".domain").style("shape-rendering", "crispEdges").style(
-        "stroke",
-        formatOptions.xAxisLabel.xAxisColor
-      ).attr("stroke-width", formatOptions.xAxisLabel.xAxisWidth ? formatOptions.xAxisLabel.xAxisWidth : formatOptions.plotArea.plotAreaBorderThickness);
+      if (xAxisTop) {
+        const YaxisRightG = gTag.append("g").attr("transform", `translate(${xScaleBottom(0)},0)`).call(xAxisTop);
+        YaxisRightG.selectAll("line").style("shape-rendering", "crispEdges").style("stroke", formatOptions.plotArea.gridLinesColor).attr(
+          "visibility",
+          formatOptions.xAxisLabel.xAxisLabelVisibility ? "visible" : formatOptions.plotArea.gridLinesVertical ? "visible" : "hidden"
+        );
+        YaxisRightG.select(".domain").style("shape-rendering", "crispEdges").style("stroke", formatOptions.xAxisLabel.xAxisColor).attr(
+          "stroke-width",
+          formatOptions.xAxisLabel.xAxisWidth ?? formatOptions.plotArea.plotAreaBorderThickness
+        );
+      }
     } else {
       YaxisG.selectAll("text").style(
         "visibility",
@@ -14702,7 +14712,7 @@ const dataLabelsPositionForBarChartFamily = (formatOptions, xCordinate, position
       formatOptions.plotArea.plotAreaDisplayUnits,
       formatOptions.annotation.annotationNumberFormat,
       formatOptions.annotation.annotationDecimalPrecision,
-      chartType === actualChartTypes.tornadoChart
+      chartType === chartTypes.TornadoChart
     );
     const formattedLength = String(formattedValue).length;
     const scaledX = xScale(xCordinate);
@@ -14978,33 +14988,33 @@ const chartProperties = {
 };
 const fileName$b = "CommonFunctions.ts";
 [
-  actualChartTypes.bar,
-  actualChartTypes.stackColumn,
-  actualChartTypes.stackColumn100,
-  actualChartTypes.line,
-  actualChartTypes.stackLine,
-  actualChartTypes.stackLine100,
-  actualChartTypes.area,
-  actualChartTypes.stackArea,
-  actualChartTypes.stackArea100
+  chartTypes.ColumnChart,
+  chartTypes.StackColumnChart,
+  chartTypes.NormalizedStackColumnChart,
+  chartTypes.LineChart,
+  chartTypes.StackLineChart,
+  chartTypes.NormalizedStackLineChart,
+  chartTypes.AreaChart,
+  chartTypes.StackAreaChart,
+  chartTypes.NormalizedStackAreaChart
 ];
 [
-  actualChartTypes.pie,
-  actualChartTypes.pieOfPie,
-  actualChartTypes.sunburst,
-  actualChartTypes.pyramidChart,
-  actualChartTypes.organizationalChart,
-  actualChartTypes.vennDiagramChart,
-  actualChartTypes.progressChart,
-  actualChartTypes.maps,
-  actualChartTypes.wordCloud,
-  actualChartTypes.sankey,
-  actualChartTypes.speedometerChart,
-  actualChartTypes.radialBarChart
+  chartTypes.PieChart,
+  chartTypes.PieofPie,
+  chartTypes.DonutChart,
+  chartTypes.PyramidChart,
+  chartTypes.OrganizationChart,
+  chartTypes.VennChart,
+  chartTypes.ProgressChart,
+  chartTypes.Maps,
+  chartTypes.WordCloud,
+  chartTypes.SankeyChart,
+  chartTypes.Speedometer,
+  chartTypes.RadialBarChart
 ];
-function drawLegends(height, svg, maxLegendDimensions, chartTitleHeight, width, legendMargin, formatOptions, inputSeries, chartId, legendShape) {
+function drawLegends(height, svg, maxLegendDimensions, chartTitleHeight, width, legendMargin, formatOptions, inputSeries, chartId, legendShape, chartType) {
   try {
-    let seriesData = [...inputSeries].reverse();
+    let seriesData = chartType !== chartTypes.TornadoChart ? [...inputSeries].reverse() : [...inputSeries];
     let position = formatOptions.legends.legendPosition;
     let horizontalLegendAlignment = formatOptions.legends.legendAlignmentTopBottom;
     let verticalLegendAlignment = formatOptions.legends.legendAlignment;
@@ -15133,12 +15143,12 @@ function lineMarkers(lines, chartData, type, xScale, yScale, yScaleRight, toolti
         return Symbol$1().type(Markershapes(d.markerShape)).size(d.markerSize * 50)();
       }).attr("visibility", (d) => {
         const hideByX = !xScale(d.dimension) && xScale(d.dimension) !== 0;
-        const visible = formatOptions.marker.markerVisibility ? checkVisibleConditions(chartData, d, type, hideZeroValues, secondaryCustomYaxisMaxValue, secondaryCustomYaxisMinValue, customYaxisMinValue, customYaxisMaxValue) ? "hidden" : [actualChartTypes.stackLine100, "CombiLine"].includes(type) ? "visible" : [actualChartTypes.stackArea, actualChartTypes.area, "CombiArea", "CombiStackArea"].includes(type) ? formatOptions.plotArea.plotAreaHideLineAndMarkers ? "visible" : "hidden" : "visible" : type === "CombiLine" ? "visible" : ["Area", "CombiArea"].includes(type) ? formatOptions.plotArea.plotAreaHideLineAndMarkers ? "visible" : "hidden" : "hidden";
+        const visible = formatOptions.marker.markerVisibility ? checkVisibleConditions(chartData, d, type, hideZeroValues, secondaryCustomYaxisMaxValue, secondaryCustomYaxisMinValue, customYaxisMinValue, customYaxisMaxValue) ? "hidden" : [chartTypes.NormalizedStackLineChart, "CombiLine"].includes(type) ? "visible" : [chartTypes.StackAreaChart, chartTypes.AreaChart, "CombiArea", "CombiStackArea"].includes(type) ? formatOptions.plotArea.plotAreaHideLineAndMarkers ? "visible" : "hidden" : "visible" : type === "CombiLine" ? "visible" : ["Area", "CombiArea"].includes(type) ? formatOptions.plotArea.plotAreaHideLineAndMarkers ? "visible" : "hidden" : "hidden";
         return hideByX ? "hidden" : visible;
       }).attr("transform", (d) => {
         let requiredYScale = d.axis == "Primary" ? yScale : yScaleRight;
         const x2 = xScale(d.dimension);
-        const y2 = [actualChartTypes.stackArea100, actualChartTypes.stackArea, actualChartTypes.stackLine, actualChartTypes.stackLine100, "CombiStackArea"].includes(type) ? d[1] > 0 ? requiredYScale(d[1]) : requiredYScale(d[0]) : requiredYScale(d.value);
+        const y2 = [chartTypes.NormalizedStackAreaChart, chartTypes.StackAreaChart, chartTypes.StackLineChart, chartTypes.NormalizedStackLineChart, "CombiStackArea"].includes(type) ? d[1] > 0 ? requiredYScale(d[1]) : requiredYScale(d[0]) : requiredYScale(d.value);
         return `translate(${x2},${y2})`;
       }).on("mousemove", function(event2, d) {
         const dataPoint = d;
@@ -15155,7 +15165,7 @@ function lineMarkers(lines, chartData, type, xScale, yScale, yScaleRight, toolti
             {
               key: formatOptions.yAxisTitle.yAxisTitleText || dataPoint.value,
               value: getNumberWithFormat(
-                [actualChartTypes.stackLine100, actualChartTypes.stackArea100, ""].includes(type) ? dataPoint[1] - dataPoint[0] : dataPoint.value,
+                [chartTypes.NormalizedStackLineChart, chartTypes.NormalizedStackAreaChart, ""].includes(type) ? dataPoint[1] - dataPoint[0] : dataPoint.value,
                 formatOptions.toolTip.toolTipDisplayUnits,
                 formatOptions.toolTip.toolTipNumberFormat,
                 formatOptions.toolTip.toolTipDecimalPrecision
@@ -15177,12 +15187,12 @@ function lineMarkers(lines, chartData, type, xScale, yScale, yScaleRight, toolti
         parentG.selectAll(".halo").remove();
         parentG.insert("circle", ":first-child").attr("class", "halo").attr("cx", xScale(dataPoint.dimension)).attr("cy", () => {
           const requiredYScale = dataPoint.axis === "Primary" ? yScale : yScaleRight;
-          return [actualChartTypes.stackArea100, actualChartTypes.stackArea, actualChartTypes.stackLine, actualChartTypes.stackLine100, "CombiStackArea"].includes(type) ? dataPoint[1] > 0 ? requiredYScale(dataPoint[1]) : requiredYScale(dataPoint[0]) : requiredYScale(dataPoint.value);
+          return [chartTypes.NormalizedStackAreaChart, chartTypes.StackAreaChart, chartTypes.StackLineChart, chartTypes.NormalizedStackLineChart, "CombiStackArea"].includes(type) ? dataPoint[1] > 0 ? requiredYScale(dataPoint[1]) : requiredYScale(dataPoint[0]) : requiredYScale(dataPoint.value);
         }).attr("fill", legendEntry.markerColor).attr("opacity", 0.5).attr("r", legendEntry.markerSize * 10);
         select$2(this).transition().duration(100).attr("transform", () => {
           const requiredYScale = dataPoint.axis === "Primary" ? yScale : yScaleRight;
           const x2 = xScale(dataPoint.dimension);
-          const y2 = [actualChartTypes.stackArea100, actualChartTypes.stackArea, actualChartTypes.stackLine, actualChartTypes.stackLine100, "CombiStackArea"].includes(type) ? dataPoint[1] > 0 ? requiredYScale(dataPoint[1]) : requiredYScale(dataPoint[0]) : requiredYScale(dataPoint.value);
+          const y2 = [chartTypes.NormalizedStackAreaChart, chartTypes.StackAreaChart, chartTypes.StackLineChart, chartTypes.NormalizedStackLineChart, "CombiStackArea"].includes(type) ? dataPoint[1] > 0 ? requiredYScale(dataPoint[1]) : requiredYScale(dataPoint[0]) : requiredYScale(dataPoint.value);
           return `translate(${x2},${y2}) scale(1.3)`;
         });
       }).on("mouseout", function(event2, d) {
@@ -15193,7 +15203,7 @@ function lineMarkers(lines, chartData, type, xScale, yScale, yScaleRight, toolti
         select$2(this).transition().duration(100).attr("transform", () => {
           const requiredYScale = dataPoint.axis === "Primary" ? yScale : yScaleRight;
           const x2 = xScale(dataPoint.dimension);
-          const y2 = [actualChartTypes.stackArea100, actualChartTypes.stackArea, actualChartTypes.stackLine, actualChartTypes.stackLine100, "CombiStackArea"].includes(type) ? dataPoint[1] > 0 ? requiredYScale(dataPoint[1]) : requiredYScale(dataPoint[0]) : requiredYScale(dataPoint.value);
+          const y2 = [chartTypes.NormalizedStackAreaChart, chartTypes.StackAreaChart, chartTypes.StackLineChart, chartTypes.NormalizedStackLineChart, "CombiStackArea"].includes(type) ? dataPoint[1] > 0 ? requiredYScale(dataPoint[1]) : requiredYScale(dataPoint[0]) : requiredYScale(dataPoint.value);
           return `translate(${x2},${y2}) scale(1)`;
         });
       });
@@ -15237,7 +15247,7 @@ function onHoverMarkerForAreaChartFamily(formatOptions, areas, focus, filteredDi
           { key: formatOptions.xAxisTitle.xAxisTitleText, value: lineData[legendIndex].data[dimensionIndex].dimension },
           {
             key: lineData[legendIndex].properties.currentMeasure ? lineData[legendIndex].properties.currentMeasure : this.basestyle.YAxisTitle.YAxisTitleText,
-            value: getNumberWithFormat(chartType === actualChartTypes.stackArea100 ? legendIndex === 0 ? lineData[legendIndex].data[dimensionIndex].value : lineData[legendIndex].data[dimensionIndex].value - lineData[legendIndex - 1].data[dimensionIndex].value : lineData[legendIndex].data[dimensionIndex].value, formatOptions.toolTip.toolTipDisplayUnits, formatOptions.toolTip.toolTipNumberFormat, formatOptions.toolTip.toolTipDecimalPrecision)
+            value: getNumberWithFormat(chartType === chartTypes.NormalizedStackAreaChart ? legendIndex === 0 ? lineData[legendIndex].data[dimensionIndex].value : lineData[legendIndex].data[dimensionIndex].value - lineData[legendIndex - 1].data[dimensionIndex].value : lineData[legendIndex].data[dimensionIndex].value, formatOptions.toolTip.toolTipDisplayUnits, formatOptions.toolTip.toolTipNumberFormat, formatOptions.toolTip.toolTipDecimalPrecision)
           },
           { key: "Legend", value: lineData[legendIndex].data[dimensionIndex].legend.includes("~$~") ? lineData[legendIndex].data[dimensionIndex].legend.split("~$~")[1] : lineData[legendIndex].data[dimensionIndex].legend }
           // { key: "Calculated Tooltip", value: lineData[legendIndex].data[dimensionIndex]. },
@@ -15603,11 +15613,11 @@ const legendsWithScroll = (svg, seriesData, x2, y2, width, height, legendPositio
         let customLegendShape;
         if (!legendShape) {
           let legendType = d.properties.type;
-          if (legendType == actualChartTypes.column || legendType == actualChartTypes.stackColumn) {
+          if (legendType == chartTypes.ColumnChart || legendType == chartTypes.StackColumnChart) {
             customLegendShape = staticLegendShape.rectangle;
-          } else if (legendType == actualChartTypes.line || legendType == actualChartTypes.stackLine) {
+          } else if (legendType == chartTypes.LineChart || legendType == chartTypes.StackLineChart) {
             customLegendShape = staticLegendShape.line;
-          } else if (legendType == actualChartTypes.area || legendType == actualChartTypes.stackArea) {
+          } else if (legendType == chartTypes.AreaChart || legendType == chartTypes.StackAreaChart) {
             customLegendShape = staticLegendShape.areaWithLine;
           }
         }
@@ -16006,7 +16016,7 @@ function generalizedChartData(chartData, dimensionList) {
       return {
         ...item,
         properties,
-        data: normalizedData
+        data: item.data
       };
     });
   } catch (error) {
@@ -16126,12 +16136,13 @@ const getHoverId = (inputText) => {
 const ColumnChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   let columnWidth = 0;
   let scrollbarVisible = false;
-  const chartType = actualChartTypes.column;
+  const chartType = chartTypes.ColumnChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -16565,8 +16576,8 @@ const ColumnChart = ({
               key: formatOptions.yAxisTitle.yAxisTitleText || d.value,
               value: getNumberWithFormat(
                 [
-                  actualChartTypes.stackLine100,
-                  actualChartTypes.stackArea100,
+                  chartTypes.NormalizedStackLineChart,
+                  chartTypes.NormalizedStackAreaChart,
                   ""
                 ].includes(chartType) ? d[1] - d[0] : d.value,
                 formatOptions.toolTip.toolTipDisplayUnits,
@@ -16649,7 +16660,8 @@ const ColumnChart = ({
       chartId,
       svg,
       xScaleForLegends,
-      columnWidth
+      columnWidth,
+      isReportEditable
     );
     addDataTable(
       formatOptions.plotArea.fitChart,
@@ -16690,13 +16702,14 @@ const ColumnChart = ({
 const CustomColumnChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   let columnWidth = 0;
   let scrollbarVisible = false;
   let stackChartData = [];
-  const chartType = actualChartTypes.customColumnChart;
+  const chartType = chartTypes.CustomColumnChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -16738,6 +16751,7 @@ const CustomColumnChart = ({
   let yScaleRight;
   let xScale;
   let xScaleForLegends;
+  let calculatedRange;
   let stackAreaChartDataForPrimaryAxis = [];
   let stackAreaChartDataForSecondaryAxis = [];
   let stackColumnChartDataForPrimaryAxis = [];
@@ -16803,7 +16817,10 @@ const CustomColumnChart = ({
       chartTitleHeight,
       secondaryAxisTitleWidth,
       legendMargin,
-      secondaryYLabel
+      secondaryYLabel,
+      visibleBars,
+      columnWidth,
+      scrollbarVisible
     } = marginCalculation(
       // for all margin related calculations
       width,
@@ -16939,27 +16956,27 @@ const CustomColumnChart = ({
     let yMinRight = Infinity;
     let tempChartData = [];
     seriesData.forEach((series, i) => {
-      if (![actualChartTypes.stackColumn, actualChartTypes.stackArea].includes(series.properties.type)) {
+      if (![chartTypes.StackColumnChart, chartTypes.StackAreaChart].includes(series.properties.type)) {
         tempChartData.push(series);
-        series.properties.type !== actualChartTypes.line && legendList.push(series.legend);
+        series.properties.type !== chartTypes.LineChart && legendList.push(series.legend);
       } else if (!legendList.includes("stackLegend")) {
         legendList.push(`stackLegend`);
       }
       if (series.properties.axis === "Secondary") {
         secondaryStackAxisData.push(series);
-        if (series.properties.type == actualChartTypes.stackColumn) {
+        if (series.properties.type == chartTypes.StackColumnChart) {
           secondaryStackColumnAxisData.push(series);
         }
-        if (series.properties.type == actualChartTypes.stackArea) {
+        if (series.properties.type == chartTypes.StackAreaChart) {
           secondaryStackAreaAxisData.push(series);
         }
       }
       if (series.properties.axis === "Primary") {
         primaryStackAxisData.push(series);
-        if (series.properties.type == actualChartTypes.stackColumn) {
+        if (series.properties.type == chartTypes.StackColumnChart) {
           primaryStackColumnAxisData.push(series);
         }
-        if (series.properties.type == actualChartTypes.stackArea) {
+        if (series.properties.type == chartTypes.StackAreaChart) {
           primaryStackAreaAxisData.push(series);
         }
       }
@@ -17171,6 +17188,13 @@ const CustomColumnChart = ({
         0
       ]);
     }
+    calculatedRange = [0, innerWidth2];
+  };
+  const getXScale = () => {
+    xScaleForLegends = band().domain(chartJSON.legendList).range([0, columnWidth]).paddingInner(
+      chartJSON.legendList.length > 1 ? 0.3 * parseFloat(formatOptions.plotArea.plotAreaSeriesWidth) / 100 : 0
+    );
+    xScale = point$7().domain(filteredDimension).range(calculatedRange).padding(0.5);
   };
   const initAxis = () => {
     {
@@ -17223,23 +17247,28 @@ const CustomColumnChart = ({
       ).tickPadding(8).tickSizeOuter(0);
     }
   };
+  const getXAxis = () => {
+    xAxis = axisBottom(xScale).tickSize(
+      formatOptions.plotArea.gridLinesVisibility ? formatOptions.plotArea.gridLinesVertical ? formatOptions.plotArea.gridLinesVertical ? -(dataTableHeight > 0 ? innerHeight2 - dataTableHeight : innerHeight2) : parseFloat(formatOptions.plotArea.ticksHeight) * ((dataTableHeight > 0 ? innerHeight2 - dataTableHeight : innerHeight2) / 100) * (formatOptions.xAxisLabel.xAxisPosition == "1" ? 1 : -1) : 0 : 0
+    ).tickSizeOuter(0).tickValues(responsiveXaxisLabel(filteredDimension, innerWidth2));
+  };
   const getChartType = (lineData) => {
     lineData.forEach((data2) => {
       switch (data2.properties.type) {
-        case actualChartTypes.column:
+        case chartTypes.ColumnChart:
           drawColumnChart(data2);
           break;
-        case actualChartTypes.line:
+        case chartTypes.LineChart:
           drawLineChart([data2]);
           break;
-        case actualChartTypes.area:
+        case chartTypes.AreaChart:
           drawAreaChart([data2]);
           break;
-        case actualChartTypes.stackColumn:
+        case chartTypes.StackColumnChart:
           stackColumnData = createStackData(data2);
           drawStackColumnChart();
           break;
-        case actualChartTypes.stackArea:
+        case chartTypes.StackAreaChart:
           stackAreaData = createStackData(data2);
           drawStackAreaChart(data2);
           break;
@@ -17288,8 +17317,8 @@ const CustomColumnChart = ({
             key: formatOptions.yAxisTitle.yAxisTitleText || d.value,
             value: getNumberWithFormat(
               [
-                actualChartTypes.stackLine100,
-                actualChartTypes.stackArea100,
+                chartTypes.NormalizedStackLineChart,
+                chartTypes.NormalizedStackAreaChart,
                 ""
               ].includes(chartType) ? d[1] - d[0] : d.value,
               formatOptions.toolTip.toolTipDisplayUnits,
@@ -17544,7 +17573,7 @@ const CustomColumnChart = ({
     );
     filteredData = JSON.parse(JSON.stringify(requiredData));
     filteredData.forEach((data2, i) => {
-      if (data2.properties.type === actualChartTypes.stackColumn || data2.properties.type === actualChartTypes.stackArea) {
+      if (data2.properties.type === chartTypes.StackColumnChart || data2.properties.type === chartTypes.StackAreaChart) {
         data2.data.forEach(
           (stackData, pos) => filteredData[i].data[pos]["data"] = stackData.data.filter(
             (d) => filteredDimension.includes(d.dimension)
@@ -17559,6 +17588,8 @@ const CustomColumnChart = ({
     drawCustomChart();
   };
   const drawCustomChart = () => {
+    getXScale();
+    getXAxis();
     getChartType(filteredData);
     initXaxis$1(
       gTag,
@@ -17601,7 +17632,8 @@ const CustomColumnChart = ({
       innerHeight2,
       chartId,
       svg,
-      xScaleForLegends
+      xScaleForLegends,
+      isReportEditable
     );
   };
   const createStackData = (requiredStackChatData) => {
@@ -17660,11 +17692,12 @@ const CustomColumnChart = ({
 const LayeredColumnChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   let columnWidth = 0;
-  const chartType = actualChartTypes.layeredColumnChart;
+  const chartType = chartTypes.LayeredColumnChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -18043,8 +18076,8 @@ const LayeredColumnChart = ({
               key: formatOptions.yAxisTitle.yAxisTitleText || d.value,
               value: getNumberWithFormat(
                 [
-                  actualChartTypes.stackLine100,
-                  actualChartTypes.stackArea100,
+                  chartTypes.NormalizedStackLineChart,
+                  chartTypes.NormalizedStackAreaChart,
                   ""
                 ].includes(chartType) ? d[1] - d[0] : d.value,
                 formatOptions.toolTip.toolTipDisplayUnits,
@@ -18121,7 +18154,8 @@ const LayeredColumnChart = ({
       chartId,
       svg,
       void 0,
-      columnWidth
+      columnWidth,
+      isReportEditable
     );
     if (formatOptions.dataTableProperties && formatOptions.dataTableProperties.dataTable) {
       if (formatOptions.xAxisLabel.xAxisPosition != "1")
@@ -18138,7 +18172,7 @@ const LayeredColumnChart = ({
         void 0,
         void 0,
         dataTableHeight,
-        actualChartTypes.column,
+        chartTypes.ColumnChart,
         formatOptions,
         yLabel,
         yTitle,
@@ -18171,12 +18205,13 @@ const LayeredColumnChart = ({
 const StackColumnChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   let columnWidth = 0;
   let scrollbarVisible = false;
-  const chartType = actualChartTypes.stackColumn;
+  const chartType = chartTypes.StackColumnChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -18623,7 +18658,9 @@ const StackColumnChart = ({
       filteredDimension,
       innerHeight2,
       chartId,
-      svg
+      svg,
+      dataTableHeight,
+      isReportEditable
     );
     if (formatOptions.dataTableProperties && formatOptions.dataTableProperties.dataTable) {
       if (formatOptions.xAxisLabel.xAxisPosition != "1") {
@@ -18892,11 +18929,12 @@ const StackColumnChart = ({
 const NormalizedStackColumnChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   let columnWidth = 0;
-  const chartType = actualChartTypes.stackColumn100;
+  const chartType = chartTypes.NormalizedStackColumnChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -19347,7 +19385,9 @@ const NormalizedStackColumnChart = ({
       filteredDimension,
       innerHeight2,
       chartId,
-      svg
+      svg,
+      dataTableHeight,
+      isReportEditable
     );
     if (formatOptions.dataTableProperties && formatOptions.dataTableProperties.dataTable) {
       if (formatOptions.xAxisLabel.xAxisPosition != "1") {
@@ -19671,7 +19711,7 @@ function setXaxistitle(formatOptions, barChart, svg, margin, xLabel, height, xTi
     ).attr(
       "transform",
       !formatOptions.plotArea.fitChart && chartsWithXScrollFlag ? `translate(${margin.left},${margin.top + innerHeight2 + (formatOptions?.xAxisLabel?.xAxisPosition == "1" ? 0 : xLabel)})` : !formatOptions.plotArea.fitChart && chartsWithYScrollFlag ? `translate(${margin.left},${height - xTitle - 5})` : `translate(${margin.left},${margin.top + innerHeight2 + (chartsWithXScrollFlag ? formatOptions?.xAxisLabel?.xAxisPosition == "1" ? 0 : xLabel : chartType == "tornado" ? xLabel + 5 : yLabel + 5)})`
-      // `translate(${margin.left},${Margin.top + innerHeight + (chartsWithXScrollFlag ? (formatOptions?.xAxisLabel?.xAxisPosition == "1" ? 0 : Xlabel) : (attributes.type == ActualChartTypes.TornadoChart) ? Xlabel + 5 : yLabel + 5) })`
+      // `translate(${margin.left},${Margin.top + innerHeight + (chartsWithXScrollFlag ? (formatOptions?.xAxisLabel?.xAxisPosition == "1" ? 0 : Xlabel) : (attributes.type == chartTypes.TornadoChart) ? Xlabel + 5 : yLabel + 5) })`
     ).attr("class", "xAxisTitle").attr("width", innerWidth2).attr("height", xTitle + "px").style("z-index", "9999");
     if (formatOptions.xAxisTitle.xAxisDynamicTitleText.length !== 0) {
       object2.append("xhtml:div").style("color", "rgba(119,119,119)").attr("title", formatOptions.xAxisTitle.xAxisTitleText).style("white-space", "pre").style("text-overflow", "ellipsis").html(
@@ -19928,7 +19968,7 @@ const ColumnHistogramChart = ({
 }) => {
   const chartId = crypto.randomUUID();
   const columnWidth = 0;
-  const chartType = actualChartTypes.columnHistogram;
+  const chartType = chartTypes.ColumnHistogramChart;
   const svgRef = useRef();
   const seriesData = data.ChartData;
   const dimensionList = data.DimensionList;
@@ -20412,11 +20452,12 @@ const ColumnHistogramChart = ({
 const LineChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   const barWidth = 0;
-  const chartType = actualChartTypes.line;
+  const chartType = chartTypes.LineChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -20907,7 +20948,8 @@ const LineChart = ({
       filteredDimension,
       innerHeight2,
       chartId,
-      svg
+      svg,
+      isReportEditable
     );
     let newSeriesLabelArray = prepareDataForSeriesLabel(
       innerWidth2,
@@ -20960,11 +21002,12 @@ const LineChart = ({
 const StackLineChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   const barWidth = 0;
-  const chartType = actualChartTypes.stackLine;
+  const chartType = chartTypes.StackLineChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -21408,7 +21451,9 @@ const StackLineChart = ({
       filteredDimension,
       innerHeight2,
       chartId,
-      svg
+      svg,
+      dataTableHeight,
+      isReportEditable
     );
     let newSeriesLabelArray = prepareDataForSeriesLabel(
       innerWidth2,
@@ -21495,11 +21540,12 @@ const StackLineChart = ({
 const NormalisedStackLineChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   const barWidth = 0;
-  const chartType = actualChartTypes.stackLine100;
+  const chartType = chartTypes.NormalizedStackLineChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -21905,7 +21951,9 @@ const NormalisedStackLineChart = ({
       filteredDimension,
       innerHeight2,
       chartId,
-      svg
+      svg,
+      dataTableHeight,
+      isReportEditable
     );
     let newSeriesLabelArray = prepareDataForSeriesLabel(
       innerWidth2,
@@ -21985,11 +22033,12 @@ const NormalisedStackLineChart = ({
 const HorizontalBarChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   let columnWidth = 0;
-  const chartType = actualChartTypes.horizontalBar;
+  const chartType = chartTypes.HorizontalBarChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -22382,7 +22431,7 @@ const HorizontalBarChart = ({
             {
               key: formatOptions.yAxisTitle.yAxisTitleText || d.value,
               value: getNumberWithFormat(
-                [actualChartTypes.stackLine100, actualChartTypes.stackArea100, ""].includes(chartType) ? d[1] - d[0] : d.value,
+                [chartTypes.NormalizedStackLineChart, chartTypes.NormalizedStackAreaChart, ""].includes(chartType) ? d[1] - d[0] : d.value,
                 formatOptions.toolTip.toolTipDisplayUnits,
                 formatOptions.toolTip.toolTipNumberFormat,
                 formatOptions.toolTip.toolTipDecimalPrecision
@@ -22465,6 +22514,7 @@ const HorizontalBarChart = ({
       yScaleLegends,
       columnWidth,
       false,
+      isReportEditable,
       barChart
     );
   };
@@ -22481,11 +22531,12 @@ const HorizontalBarChart = ({
 const StackHorizontalChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   let columnWidth = 0;
-  const chartType = actualChartTypes.stackBar;
+  const chartType = chartTypes.StackHorizontalBarChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -22919,6 +22970,7 @@ const StackHorizontalChart = ({
       chartId,
       svg,
       0,
+      isReportEditable,
       barChart
     );
     getConnectors();
@@ -23171,11 +23223,12 @@ const StackHorizontalChart = ({
 const NormalizedStackHorizontalBarChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   let columnWidth = 0;
-  const chartType = actualChartTypes.stackBar100;
+  const chartType = chartTypes.NormalizedStackHorizontalBarChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(data.ChartData, data.DimensionList)?.reverse();
   const dimensionList = data.DimensionList;
@@ -23581,6 +23634,7 @@ const NormalizedStackHorizontalBarChart = ({
       chartId,
       svg,
       0,
+      isReportEditable,
       barChart
     );
   };
@@ -23631,11 +23685,12 @@ const NormalizedStackHorizontalBarChart = ({
 const LayeredHorizontalBarChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   let columnWidth = 0;
-  const chartType = actualChartTypes.layeredBarChart;
+  const chartType = chartTypes.LayeredHorizontalBarChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -23982,8 +24037,8 @@ const LayeredHorizontalBarChart = ({
               key: formatOptions.yAxisTitle.yAxisTitleText || d.value,
               value: getNumberWithFormat(
                 [
-                  actualChartTypes.stackLine100,
-                  actualChartTypes.stackArea100,
+                  chartTypes.NormalizedStackLineChart,
+                  chartTypes.NormalizedStackAreaChart,
                   ""
                 ].includes(chartType) ? d[1] - d[0] : d.value,
                 formatOptions.toolTip.toolTipDisplayUnits,
@@ -24071,6 +24126,7 @@ const LayeredHorizontalBarChart = ({
       yScale,
       columnWidth,
       false,
+      isReportEditable,
       barChart
     );
     getConnectors();
@@ -24312,7 +24368,7 @@ const HorizontalHistogramChart = ({
 }) => {
   const chartId = crypto.randomUUID();
   const columnWidth = 0;
-  const chartType = actualChartTypes.columnHistogram;
+  const chartType = chartTypes.ColumnHistogramChart;
   const svgRef = useRef();
   const seriesData = data.ChartData;
   const dimensionList = data.DimensionList;
@@ -24779,11 +24835,12 @@ const HorizontalHistogramChart = ({
 const AreaChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   const barWidth = 0;
-  const chartType = actualChartTypes.area;
+  const chartType = chartTypes.AreaChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -25248,7 +25305,8 @@ const AreaChart = ({
       filteredDimension,
       innerHeight2,
       chartId,
-      svg
+      svg,
+      isReportEditable
     );
     let newSeriesLabelArray = prepareDataForSeriesLabel(
       innerWidth2,
@@ -25302,11 +25360,12 @@ const AreaChart = ({
 const StackAreaChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   const barWidth = 0;
-  const chartType = actualChartTypes.stackArea;
+  const chartType = chartTypes.StackAreaChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -25787,7 +25846,9 @@ const StackAreaChart = ({
       filteredDimension,
       innerHeight2,
       chartId,
-      svg
+      svg,
+      dataTableHeight,
+      isReportEditable
     );
     let newSeriesLabelArray = prepareDataForSeriesLabel(
       innerWidth2,
@@ -25867,11 +25928,12 @@ const StackAreaChart = ({
 const NormalizedStackAreaChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   const barWidth = 0;
-  const chartType = actualChartTypes.stackArea100;
+  const chartType = chartTypes.NormalizedStackAreaChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(
     data.ChartData,
@@ -26348,7 +26410,9 @@ const NormalizedStackAreaChart = ({
       filteredDimension,
       innerHeight2,
       chartId,
-      svg
+      svg,
+      dataTableHeight,
+      isReportEditable
     );
     let newSeriesLabelArray = prepareDataForSeriesLabel(
       innerWidth2,
@@ -53160,7 +53224,7 @@ const WaterfallChart = ({
   const chartId = crypto.randomUUID?.();
   let columnWidth = 0;
   let colorScale;
-  const chartType = actualChartTypes.waterfall;
+  const chartType = chartTypes.WaterfallChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(data.ChartData, data.DimensionList);
   const dimensionList = data.DimensionList;
@@ -53792,11 +53856,12 @@ const WaterfallChart = ({
 const TornadoChart = ({
   isDateType,
   formatOptions,
-  data
+  data,
+  isReportEditable
 }) => {
   const chartId = crypto.randomUUID();
   let columnWidth = 0;
-  const chartType = actualChartTypes.tornadoChart;
+  const chartType = chartTypes.TornadoChart;
   const svgRef = useRef();
   const seriesData = generalizedChartData(data.ChartData, data.DimensionList);
   const dimensionList = data.DimensionList;
@@ -53832,13 +53897,11 @@ const TornadoChart = ({
   let svg;
   let gTag;
   let yScaleLeft;
-  let yScaleRight;
   let xScale;
   let xScaleForLegends;
   let calculatedRange;
   let yAxisLeft;
   let xAxis;
-  let yAxisRight;
   let filteredDimension;
   let filteredData = [];
   let isSensitivityChart = false;
@@ -53849,7 +53912,7 @@ const TornadoChart = ({
     chartType,
     chartData: [],
     formatOptions,
-    legendList: [],
+    legendList: data.LegendList,
     secondaryAxisDrawn: false,
     yMaxLeft: 0,
     yMaxRight: 0,
@@ -53898,7 +53961,7 @@ const TornadoChart = ({
       maxNumberForSecondaryAxis,
       chartJSON.yMaxLeft,
       formatOptions,
-      chartJSON.legendList,
+      chartJSON.legendList.map((d) => d["alias"]),
       chartJSON.dimensionList,
       chartJSON.yMaxRight,
       isSecondaryAxisDrawn,
@@ -53939,7 +54002,7 @@ const TornadoChart = ({
       innerHeight2,
       innerWidth2,
       yAxisLeft,
-      yAxisRight,
+      null,
       xScale,
       chartJSON.yMaxLeft,
       chartJSON.dimensionList,
@@ -54021,53 +54084,59 @@ const TornadoChart = ({
       width,
       legendMargin,
       formatOptions,
-      seriesData,
+      mapSeriesDataWithLegendList(seriesData, chartJSON.legendList),
       chartId,
-      staticLegendShape.rectangle
+      staticLegendShape.rectangle,
+      chartType
+    );
+  };
+  const mapSeriesDataWithLegendList = (seriesData2, legendList) => {
+    return seriesData2.map((series, index2) => ({
+      ...series,
+      properties: legendList[index2] ? { ...legendList[index2] } : {}
+    })).filter(
+      (series) => series.properties && Object.keys(series.properties).length > 0
     );
   };
   const preProcessChartData = () => {
-    const allChartData = [];
-    const legendList = [];
-    let formatedDimensionList = [];
-    let firstMeasure = seriesData[0]?.properties.currentMeasure;
+    const firstMeasure = seriesData[0]?.properties.currentMeasure;
     let yMaxLeft = 0;
     let yMaxRight = -Infinity;
-    seriesData.forEach((series) => {
-      legendList.push(series.legend);
-      series.data.forEach((point2) => {
-        if (series.properties.currentMeasure === firstMeasure) {
-          point2.value = -point2.value;
-        }
-        allChartData.push(point2);
+    const processedSeriesData = seriesData.map((series) => {
+      const isFirstMeasure = series.properties.currentMeasure === firstMeasure;
+      const newData = series.data.map((point2) => {
+        const newValue = isFirstMeasure ? -Math.abs(point2.value) : Math.abs(point2.value);
+        return {
+          ...point2,
+          value: newValue
+        };
       });
-      let measuresArray = series.data.map((d) => d.value);
-      if (series.properties.currentMeasure === firstMeasure) {
-        yMaxLeft = Math.min(yMaxLeft, Math.min(...measuresArray));
-      } else {
-        yMaxRight = Math.max(yMaxRight, Math.max(...measuresArray));
-      }
+      const values = newData.map((d) => d.value);
+      if (isFirstMeasure) yMaxLeft = Math.min(yMaxLeft, Math.min(...values));
+      else yMaxRight = Math.max(yMaxRight, Math.max(...values));
+      return {
+        ...series,
+        data: newData
+      };
     });
-    chartJSON.chartData = allChartData;
-    chartJSON.legendList = legendList;
+    chartJSON.chartData = processedSeriesData;
     chartJSON.yMaxLeft = yMaxLeft;
     chartJSON.yMaxRight = yMaxRight;
-    formatedDimensionList = isDateType ? setDateFormats(
+    const formatedDimensionList = isDateType ? setDateFormats(
       formatOptions.xAxisLabel.xAxisNumberFormat,
       chartJSON.dimensionList
-    ).map((d) => d) : chartJSON.dimensionList;
+    ) : chartJSON.dimensionList;
     chartJSON.dimensionList.forEach((dim, i) => {
-      chartJSON.formattedDimensionListMap.set(dim, formatedDimensionList[i]);
-    });
-    filteredData = JSON.parse(JSON.stringify(seriesData));
-    if (!formatOptions.plotArea.fitChart) {
-      filteredDimension = chartJSON.dimensionList.slice(
-        scrollPosition,
-        scrollPosition + visibleBars
+      chartJSON.formattedDimensionListMap.set(
+        dim,
+        formatedDimensionList[i]
       );
-    } else {
-      filteredDimension = chartJSON.dimensionList;
-    }
+    });
+    filteredData = JSON.parse(JSON.stringify(processedSeriesData));
+    filteredDimension = !formatOptions.plotArea.fitChart ? chartJSON.dimensionList.slice(
+      scrollPosition,
+      scrollPosition + visibleBars
+    ) : chartJSON.dimensionList;
     if (formatOptions.plotArea.hideZeroValues) {
       chartJSON.hideZeroValues = true;
     }
@@ -54086,18 +54155,7 @@ const TornadoChart = ({
     }
     let adjustedPosition = formatOptions.annotation.annotationVisibility != "5" && formatOptions.annotation.annotationPosition == "1" ? 20 : 0;
     let scaleFactor = formatOptions.annotation.annotationVisibility != "5" ? chartJSON.yMaxLeft / maxValue !== 1 ? Math.abs(chartJSON.yMaxLeft / maxValue) * 100 < 10 ? 3 : 0 : Math.abs(chartJSON.yMaxRight / maxValue) * 100 < 10 ? 3 : 0 : 0;
-    let yAxisLabelArray = responsiveYaxisLabel$1(
-      chartJSON.yMaxRight,
-      chartJSON.yMaxLeft,
-      innerHeight2,
-      formatOptions,
-      chartJSON,
-      customYaxisMinValue,
-      customYaxisMaxValue,
-      barChart,
-      innerWidth2
-    ).yAxisLabelArray;
-    chartJSON.yMaxLeft = yAxisLabelArray[0];
+    chartJSON.yMaxLeft = chartJSON.yMaxLeft;
     xScaleForLegends = linear$1().domain([chartJSON.yMaxLeft * (1.2 + (left2 ? scaleFactor : 0)), chartJSON.yMaxRight * (1.2 + (right2 ? scaleFactor : 0))]).range([adjustedPosition, innerWidth2 - adjustedPosition]);
     xScale = xScaleForLegends;
     calculatedRange = [0, innerWidth2];
@@ -54111,7 +54169,7 @@ const TornadoChart = ({
     yAxisLeft = axisLeft(yScaleLeft).tickSize(
       formatOptions.plotArea.gridLinesVisibility ? formatOptions.plotArea.gridLinesHorizontal ? -(innerWidth2 - xScaleForLegends(0)) : 0 : 0
     ).tickSizeOuter(0).tickValues(responsiveXaxisLabel(chartJSON.dimensionList, innerWidth2));
-    yAxisRight = axisRight(yScaleLeft).tickSize(
+    axisRight(yScaleLeft).tickSize(
       formatOptions.plotArea.gridLinesVisibility ? formatOptions.plotArea.gridLinesHorizontal ? -xScaleForLegends(0) : 0 : 0
     ).tickSizeOuter(0).tickValues(responsiveXaxisLabel(chartJSON.dimensionList, innerWidth2));
   };
@@ -54152,29 +54210,46 @@ const TornadoChart = ({
       ).customTickValue ?? (dataTableHeight > 0 ? (innerWidth2 - dataTableHeight) / 30 : innerWidth2 / 30)
     ).tickPadding(8).tickSizeOuter(0);
   };
-  const getChartType = (lineData) => {
+  const getChartType = () => {
+    gTag.selectAll(".parentGroup").remove();
     formatOptions.plotArea.plotAreaCalculatedHigh;
     formatOptions.plotArea.plotAreaCalculatedLow;
-    gTag.append("g").attr("class", "parentGroup").selectAll("#scaling-svg" + chartId + " .rect").data(filteredData).enter().append("g").attr("class", (d) => d.data[0].legend.replace(/ /g, "-")).selectAll("rect").data((d) => d.data.map((child) => ({
-      ...child,
-      parentProperties: d.properties
-    }))).enter().append("rect").attr("class", "rect").attr("y", (d) => d.dimension ? yScaleLeft(d.dimension) : yScaleLeft("defaultEntry")).attr("x", (d) => xScale(Math.max(0, d.value))).attr("stroke-dasharray", (d) => d.stackBorderStyle == 2 ? "5,3" : "0").attr("stroke-width", (d) => d.stackBorderWidth + "px").attr("stroke", (d) => d.stackBorderStyle == 0 ? "none" : formatOptions.column.stackBorderVisibility ? d.stackBorderColor : "none").style("shape-rendering", "crispEdges").attr("width", (d) => d.value ? Math.abs(xScale(d.value) - xScale(0)) : 0).attr("height", yScaleLeft.bandwidth()).style("fill", (d) => d.parentProperties.color).attr("opacity", 1).on("mousemove", (event2, d) => {
+    const parent = gTag.append("g").attr("class", "parentGroup");
+    parent.selectAll("rect").data(
+      filteredData.flatMap(
+        (d) => d.data.map((child) => ({
+          ...child,
+          legendText: d.legend.replace("-", "~$~").split("~$~")[1].trim(),
+          properties: d.properties
+        }))
+      )
+    ).enter().append("rect").attr("class", "rect").attr("y", (d) => d.legendText ? yScaleLeft(d.legendText) : yScaleLeft("defaultEntry")).attr("height", yScaleLeft.bandwidth()).attr("x", (d) => d.value >= 0 ? xScale(0) : xScale(d.value)).attr("width", (d) => Math.abs(xScale(d.value) - xScale(0))).style("shape-rendering", "crispEdges").attr("stroke-dasharray", (d) => d.properties.stackBorderStyle == 2 ? "5,3" : "0").attr("stroke-width", (d) => `${d.properties.stackBorderWidth}px`).attr(
+      "stroke",
+      (d) => d.properties.stackBorderStyle == 0 ? "none" : formatOptions.column.stackBorderVisibility ? d.properties.stackBorderColor : "none"
+    ).style(
+      "fill",
+      (d) => d.properties.color
+    ).on("mousemove", (event2, d) => {
       showTooltipOnMouseMove(
         [
-          { key: "Measure", value: d.legend },
-          { key: "Legend", value: d.dimension },
+          { key: "Measure", value: d.dimension },
+          { key: "Legend", value: d.legendText },
           {
             key: "Value",
-            value: d.value < 0 ? getNumberWithFormat(-d.value, formatOptions.toolTip.toolTipDisplayUnits, formatOptions.toolTip.toolTipNumberFormat, formatOptions.toolTip.toolTipDecimalPrecision, true) : getNumberWithFormat(d.value, formatOptions.toolTip.toolTipDisplayUnits, formatOptions.toolTip.toolTipNumberFormat, formatOptions.toolTip.toolTipDecimalPrecision, true)
+            value: getNumberWithFormat(
+              Math.abs(d.value),
+              formatOptions.toolTip.toolTipDisplayUnits,
+              formatOptions.toolTip.toolTipNumberFormat,
+              formatOptions.toolTip.toolTipDecimalPrecision,
+              true
+            )
           }
         ],
         formatOptions,
-        void 0,
-        d.parentProperties
+        event2,
+        d.properties
       );
-    }).on("mouseout", () => {
-      hideTooltipOnMouseOut();
-    });
+    }).on("mouseout", hideTooltipOnMouseOut);
   };
   const setSVGContainer = (margin2) => {
     innerWidth2 = width - margin2.left - margin2.right;
@@ -54257,7 +54332,7 @@ const TornadoChart = ({
       filteredData,
       yScaleLeft,
       xScale,
-      yScaleRight,
+      null,
       // need to pass secondary axis scale if secondary axis is drawn
       margin,
       d3Annotation,
@@ -54279,6 +54354,7 @@ const TornadoChart = ({
       yScaleLeft,
       columnWidth,
       isSensitivityChart,
+      isReportEditable,
       barChart
     );
   };