@fluentui/react-charts 0.0.0-nightly-20250423-1342.1 → 0.0.0-nightly-20250424-0405.1

package/lib-commonjs/utilities/utilities.js

@@ -0,0 +1,1371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ChartTypes: function() {
+        return ChartTypes;
+    },
+    CustomPoints: function() {
+        return CustomPoints;
+    },
+    HighContrastSelector: function() {
+        return HighContrastSelector;
+    },
+    HighContrastSelectorBlack: function() {
+        return HighContrastSelectorBlack;
+    },
+    HighContrastSelectorWhite: function() {
+        return HighContrastSelectorWhite;
+    },
+    Points: function() {
+        return Points;
+    },
+    XAxisTypes: function() {
+        return XAxisTypes;
+    },
+    YAxisType: function() {
+        return YAxisType;
+    },
+    areArraysEqual: function() {
+        return areArraysEqual;
+    },
+    calculateLongestLabelWidth: function() {
+        return calculateLongestLabelWidth;
+    },
+    calloutData: function() {
+        return calloutData;
+    },
+    convertToLocaleString: function() {
+        return convertToLocaleString;
+    },
+    createDateXAxis: function() {
+        return createDateXAxis;
+    },
+    createNumericXAxis: function() {
+        return createNumericXAxis;
+    },
+    createStringXAxis: function() {
+        return createStringXAxis;
+    },
+    createStringYAxis: function() {
+        return createStringYAxis;
+    },
+    createStringYAxisForHorizontalBarChartWithAxis: function() {
+        return createStringYAxisForHorizontalBarChartWithAxis;
+    },
+    createStringYAxisForOtherCharts: function() {
+        return createStringYAxisForOtherCharts;
+    },
+    createWrapOfXLabels: function() {
+        return createWrapOfXLabels;
+    },
+    createYAxis: function() {
+        return createYAxis;
+    },
+    createYAxisForHorizontalBarChartWithAxis: function() {
+        return createYAxisForHorizontalBarChartWithAxis;
+    },
+    createYAxisForOtherCharts: function() {
+        return createYAxisForOtherCharts;
+    },
+    createYAxisLabels: function() {
+        return createYAxisLabels;
+    },
+    domainRageOfVerticalNumeric: function() {
+        return domainRageOfVerticalNumeric;
+    },
+    domainRangeOfDateForAreaLineVerticalBarChart: function() {
+        return domainRangeOfDateForAreaLineVerticalBarChart;
+    },
+    domainRangeOfDateForScatterChart: function() {
+        return domainRangeOfDateForScatterChart;
+    },
+    domainRangeOfNumericForAreaChart: function() {
+        return domainRangeOfNumericForAreaChart;
+    },
+    domainRangeOfNumericForHorizontalBarChartWithAxis: function() {
+        return domainRangeOfNumericForHorizontalBarChartWithAxis;
+    },
+    domainRangeOfNumericForScatterChart: function() {
+        return domainRangeOfNumericForScatterChart;
+    },
+    domainRangeOfVSBCNumeric: function() {
+        return domainRangeOfVSBCNumeric;
+    },
+    domainRangeOfXStringAxis: function() {
+        return domainRangeOfXStringAxis;
+    },
+    find: function() {
+        return find;
+    },
+    findHBCWANumericMinMaxOfY: function() {
+        return findHBCWANumericMinMaxOfY;
+    },
+    findIndex: function() {
+        return findIndex;
+    },
+    findNumericMinMaxOfY: function() {
+        return findNumericMinMaxOfY;
+    },
+    findVSBCNumericMinMaxOfY: function() {
+        return findVSBCNumericMinMaxOfY;
+    },
+    findVerticalNumericMinMaxOfY: function() {
+        return findVerticalNumericMinMaxOfY;
+    },
+    formatDate: function() {
+        return formatDate;
+    },
+    formatValueWithSIPrefix: function() {
+        return formatValueWithSIPrefix;
+    },
+    getAccessibleDataObject: function() {
+        return getAccessibleDataObject;
+    },
+    getBarWidth: function() {
+        return getBarWidth;
+    },
+    getCurveFactory: function() {
+        return getCurveFactory;
+    },
+    getDomainNRangeValues: function() {
+        return getDomainNRangeValues;
+    },
+    getMinMaxOfYAxis: function() {
+        return getMinMaxOfYAxis;
+    },
+    getScalePadding: function() {
+        return getScalePadding;
+    },
+    getSecureProps: function() {
+        return getSecureProps;
+    },
+    getTypeOfAxis: function() {
+        return getTypeOfAxis;
+    },
+    getUnique: function() {
+        return getUnique;
+    },
+    getXAxisType: function() {
+        return getXAxisType;
+    },
+    isScalePaddingDefined: function() {
+        return isScalePaddingDefined;
+    },
+    pointTypes: function() {
+        return pointTypes;
+    },
+    prepareDatapoints: function() {
+        return prepareDatapoints;
+    },
+    resolveCSSVariables: function() {
+        return resolveCSSVariables;
+    },
+    rotateXAxisLabels: function() {
+        return rotateXAxisLabels;
+    },
+    silceOrAppendToArray: function() {
+        return silceOrAppendToArray;
+    },
+    tooltipOfXAxislabels: function() {
+        return tooltipOfXAxislabels;
+    },
+    useRtl: function() {
+        return useRtl;
+    },
+    wrapContent: function() {
+        return wrapContent;
+    },
+    wrapTextInsideDonut: function() {
+        return wrapTextInsideDonut;
+    }
+});
+const _d3axis = require("d3-axis");
+const _d3array = require("d3-array");
+const _d3scale = require("d3-scale");
+const _d3selection = require("d3-selection");
+const _d3format = require("d3-format");
+const _d3timeformat = require("d3-time-format");
+const _d3time = require("d3-time");
+const _d3shape = require("d3-shape");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+var ChartTypes;
+(function(ChartTypes) {
+    ChartTypes[ChartTypes["AreaChart"] = 0] = "AreaChart";
+    ChartTypes[ChartTypes["LineChart"] = 1] = "LineChart";
+    ChartTypes[ChartTypes["VerticalBarChart"] = 2] = "VerticalBarChart";
+    ChartTypes[ChartTypes["VerticalStackedBarChart"] = 3] = "VerticalStackedBarChart";
+    ChartTypes[ChartTypes["GroupedVerticalBarChart"] = 4] = "GroupedVerticalBarChart";
+    ChartTypes[ChartTypes["HeatMapChart"] = 5] = "HeatMapChart";
+    ChartTypes[ChartTypes["HorizontalBarChartWithAxis"] = 6] = "HorizontalBarChartWithAxis";
+    ChartTypes[ChartTypes["ScatterChart"] = 7] = "ScatterChart";
+})(ChartTypes || (ChartTypes = {}));
+var XAxisTypes;
+(function(XAxisTypes) {
+    XAxisTypes[XAxisTypes["NumericAxis"] = 0] = "NumericAxis";
+    XAxisTypes[XAxisTypes["DateAxis"] = 1] = "DateAxis";
+    XAxisTypes[XAxisTypes["StringAxis"] = 2] = "StringAxis";
+})(XAxisTypes || (XAxisTypes = {}));
+var YAxisType;
+(function(YAxisType) {
+    YAxisType[YAxisType["NumericAxis"] = 0] = "NumericAxis";
+    YAxisType[YAxisType["DateAxis"] = 1] = "DateAxis";
+    YAxisType[YAxisType["StringAxis"] = 2] = "StringAxis";
+})(YAxisType || (YAxisType = {}));
+function createNumericXAxis(xAxisParams, tickParams, chartType, culture) {
+    const { domainNRangeValues, showRoundOffXTickValues = false, xAxistickSize = 6, tickPadding = 10, xAxisCount, xAxisElement, hideTickOverlap } = xAxisParams;
+    const xAxisScale = (0, _d3scale.scaleLinear)().domain([
+        domainNRangeValues.dStartValue,
+        domainNRangeValues.dEndValue
+    ]).range([
+        domainNRangeValues.rStartValue,
+        domainNRangeValues.rEndValue
+    ]);
+    showRoundOffXTickValues && xAxisScale.nice();
+    let tickCount = xAxisCount !== null && xAxisCount !== void 0 ? xAxisCount : 6;
+    const tickFormat = (domainValue, _index)=>{
+        if (tickParams.tickFormat) {
+            return (0, _d3format.format)(tickParams.tickFormat)(domainValue);
+        }
+        const xAxisValue = typeof domainValue === 'number' ? domainValue : domainValue.valueOf();
+        return convertToLocaleString(xAxisValue, culture);
+    };
+    if (hideTickOverlap && typeof xAxisCount === 'undefined') {
+        const longestLabelWidth = calculateLongestLabelWidth(xAxisScale.ticks().map(tickFormat), '.fui-cart__xAxis text') + 20;
+        const [start, end] = xAxisScale.range();
+        tickCount = Math.max(1, Math.floor(Math.abs(end - start) / longestLabelWidth));
+    }
+    const xAxis = (0, _d3axis.axisBottom)(xAxisScale).tickSize(xAxistickSize).tickPadding(tickPadding).ticks(tickCount).tickFormat(tickFormat);
+    if (chartType === 6) {
+        xAxis.tickSizeInner(-(xAxisParams.containerHeight - xAxisParams.margins.top));
+    }
+    if (tickParams.tickValues) {
+        xAxis.tickValues(tickParams.tickValues);
+    }
+    if (xAxisElement) {
+        (0, _d3selection.select)(xAxisElement).call(xAxis).selectAll('text').attr('aria-hidden', 'true');
+    }
+    var _tickParams_tickValues;
+    const tickValues = ((_tickParams_tickValues = tickParams.tickValues) !== null && _tickParams_tickValues !== void 0 ? _tickParams_tickValues : xAxisScale.ticks(tickCount)).map(xAxis.tickFormat());
+    return {
+        xScale: xAxisScale,
+        tickValues
+    };
+}
+function multiFormat(date, locale, useUTC) {
+    const timeFormat = locale ? useUTC ? locale.utcFormat : locale.format : useUTC ? _d3timeformat.utcFormat : _d3timeformat.timeFormat;
+    const formatMillisecond = timeFormat('.%L');
+    const formatSecond = timeFormat(':%S');
+    const formatMinute = timeFormat('%I:%M');
+    const formatHour = timeFormat('%I %p');
+    const formatDay = timeFormat('%a %d');
+    const formatWeek = timeFormat('%b %d');
+    const formatMonth = timeFormat('%B');
+    const formatYear = timeFormat('%Y');
+    const timeSecond = useUTC ? _d3time.utcSecond : _d3time.timeSecond;
+    const timeMinute = useUTC ? _d3time.utcMinute : _d3time.timeMinute;
+    const timeHour = useUTC ? _d3time.utcHour : _d3time.timeHour;
+    const timeDay = useUTC ? _d3time.utcDay : _d3time.timeDay;
+    const timeMonth = useUTC ? _d3time.utcMonth : _d3time.timeMonth;
+    const timeWeek = useUTC ? _d3time.utcWeek : _d3time.timeWeek;
+    const timeYear = useUTC ? _d3time.utcYear : _d3time.timeYear;
+    return (timeSecond(date) < date ? formatMillisecond : timeMinute(date) < date ? formatSecond : timeHour(date) < date ? formatMinute : timeDay(date) < date ? formatHour : timeMonth(date) < date ? timeWeek(date) < date ? formatDay : formatWeek : timeYear(date) < date ? formatMonth : formatYear)(date);
+}
+function createDateXAxis(xAxisParams, tickParams, culture, options, timeFormatLocale, customDateTimeFormatter, useUTC) {
+    const { domainNRangeValues, xAxisElement, tickPadding = 6, xAxistickSize = 6, xAxisCount, hideTickOverlap } = xAxisParams;
+    const xAxisScale = useUTC ? (0, _d3scale.scaleUtc)() : (0, _d3scale.scaleTime)();
+    xAxisScale.domain([
+        domainNRangeValues.dStartValue,
+        domainNRangeValues.dEndValue
+    ]).range([
+        domainNRangeValues.rStartValue,
+        domainNRangeValues.rEndValue
+    ]);
+    let tickCount = xAxisCount !== null && xAxisCount !== void 0 ? xAxisCount : 6;
+    const tickFormat = (domainValue, _index)=>{
+        if (customDateTimeFormatter) {
+            return customDateTimeFormatter(domainValue);
+        }
+        if (culture && options) {
+            return domainValue.toLocaleString(culture, options);
+        }
+        if (timeFormatLocale) {
+            const locale = (0, _d3timeformat.timeFormatLocale)(timeFormatLocale);
+            return multiFormat(domainValue, locale, useUTC);
+        }
+        if (culture === undefined && tickParams.tickFormat) {
+            if (useUTC) {
+                return (0, _d3timeformat.utcFormat)(tickParams.tickFormat)(domainValue);
+            } else {
+                return (0, _d3timeformat.timeFormat)(tickParams.tickFormat)(domainValue);
+            }
+        }
+        return multiFormat(domainValue, undefined, useUTC);
+    };
+    if (hideTickOverlap && typeof xAxisCount === 'undefined') {
+        const longestLabelWidth = calculateLongestLabelWidth(xAxisScale.ticks().map(tickFormat), '.fui-cart__xAxis text') + 40;
+        const [start, end] = xAxisScale.range();
+        tickCount = Math.max(1, Math.floor(Math.abs(end - start) / longestLabelWidth));
+    }
+    const xAxis = (0, _d3axis.axisBottom)(xAxisScale).tickSize(xAxistickSize).tickPadding(tickPadding).ticks(tickCount).tickFormat(tickFormat);
+    tickParams.tickValues ? xAxis.tickValues(tickParams.tickValues) : '';
+    if (xAxisElement) {
+        (0, _d3selection.select)(xAxisElement).call(xAxis).selectAll('text').attr('aria-hidden', 'true');
+    }
+    var _tickParams_tickValues;
+    const tickValues = ((_tickParams_tickValues = tickParams.tickValues) !== null && _tickParams_tickValues !== void 0 ? _tickParams_tickValues : xAxisScale.ticks(tickCount)).map(xAxis.tickFormat());
+    return {
+        xScale: xAxisScale,
+        tickValues
+    };
+}
+function createStringXAxis(xAxisParams, tickParams, dataset, culture) {
+    const { domainNRangeValues, xAxistickSize = 6, tickPadding = 10, xAxisPadding = 0.1, xAxisInnerPadding, xAxisOuterPadding, containerWidth, hideTickOverlap } = xAxisParams;
+    const xAxisScale = (0, _d3scale.scaleBand)().domain(dataset).range([
+        domainNRangeValues.rStartValue,
+        domainNRangeValues.rEndValue
+    ]).paddingInner(typeof xAxisInnerPadding !== 'undefined' ? xAxisInnerPadding : xAxisPadding).paddingOuter(typeof xAxisOuterPadding !== 'undefined' ? xAxisOuterPadding : xAxisPadding);
+    var _tickParams_tickValues;
+    let tickValues = (_tickParams_tickValues = tickParams.tickValues) !== null && _tickParams_tickValues !== void 0 ? _tickParams_tickValues : dataset;
+    const tickFormat = (domainValue, _index)=>{
+        return convertToLocaleString(domainValue, culture);
+    };
+    if (hideTickOverlap) {
+        let nonOverlappingTickValues = [];
+        const tickSizes = tickValues.map((value, index)=>calculateLongestLabelWidth([
+                tickFormat(value, index)
+            ], '.fui-cart__xAxis text'));
+        // for LTR
+        let start = 0;
+        let end = containerWidth;
+        let sign = 1;
+        const range = xAxisScale.range();
+        if (range[1] - range[0] < 0) {
+            // for RTL
+            start = containerWidth;
+            end = 0;
+            sign = -1;
+        }
+        for(let i = tickValues.length - 1; i >= 0; i--){
+            const tickPosition = xAxisScale(tickValues[i]);
+            if (sign * (tickPosition - sign * tickSizes[i] / 2 - start) >= 0 && sign * (tickPosition + sign * tickSizes[i] / 2 - end) <= 0) {
+                nonOverlappingTickValues.push(tickValues[i]);
+                end = tickPosition - sign * (tickSizes[i] / 2 + 10);
+            }
+        }
+        nonOverlappingTickValues = nonOverlappingTickValues.reverse();
+        tickValues = nonOverlappingTickValues;
+    }
+    const xAxis = (0, _d3axis.axisBottom)(xAxisScale).tickSize(xAxistickSize).tickPadding(tickPadding).tickValues(tickValues).tickFormat(tickFormat);
+    if (xAxisParams.xAxisElement) {
+        (0, _d3selection.select)(xAxisParams.xAxisElement).call(xAxis).selectAll('text').attr('aria-hidden', 'true');
+    }
+    return {
+        xScale: xAxisScale,
+        tickValues: tickValues.map(xAxis.tickFormat())
+    };
+}
+function useRtl() {
+    const { dir } = (0, _reactsharedcontexts.useFluent_unstable)(); // "dir" returns "ltr" or "rtl"
+    return dir === 'rtl';
+}
+function isPowerOf10(num) {
+    const roundedfinalYMax = handleFloatingPointPrecisionError(num);
+    return Math.log10(roundedfinalYMax) % 1 === 0;
+}
+//for reference, go through this 'https://docs.python.org/release/2.5.1/tut/node16.html'
+function handleFloatingPointPrecisionError(num) {
+    const rounded = Math.round(num);
+    return Math.abs(num - rounded) < 1e-6 ? rounded : num;
+}
+/**
+ * This method is used to calculate the rounded tick values for the y-axis
+ * @param {number} minVal
+ * @param {number} maxVal
+ * @param {number} splitInto
+ * @returns {number[]}
+ */ function calculateRoundedTicks(minVal, maxVal, splitInto) {
+    const finalYmin = minVal >= 0 && minVal === maxVal ? 0 : minVal;
+    const finalYmax = minVal < 0 && minVal === maxVal ? 0 : maxVal;
+    const ticksInterval = (0, _d3array.nice)(finalYmin, finalYmax, splitInto);
+    const ticks = (0, _d3array.ticks)(ticksInterval[0], ticksInterval[ticksInterval.length - 1], splitInto);
+    if (ticks[ticks.length - 1] > finalYmax && isPowerOf10(finalYmax)) {
+        ticks.pop();
+    }
+    return ticks;
+}
+function prepareDatapoints(maxVal, minVal, splitInto, isIntegralDataset, roundedTicks) {
+    if (roundedTicks) {
+        return calculateRoundedTicks(minVal, maxVal, splitInto);
+    }
+    const val = isIntegralDataset ? Math.ceil((maxVal - minVal) / splitInto) : (maxVal - minVal) / splitInto >= 1 ? Math.ceil((maxVal - minVal) / splitInto) : (maxVal - minVal) / splitInto;
+    /*
+    For cases where we have negative and positive values
+    The dataPointsArray is filled from 0 to minVal by val difference
+    Then the array is reversed and values from 0(excluding 0) to maxVal are appended
+    This ensures presence of 0 to act as an anchor reference.
+    For simple cases where the scale may not encounter such a need for 0,
+    We simply fill from minVal to maxVal
+  */ const dataPointsArray = [
+        minVal < 0 && maxVal >= 0 ? 0 : minVal
+    ];
+    /*For the case of all positive or all negative, we need to add another value
+     in array for atleast one interval, but in case of mix of positive and negative,
+     there will always be one more entry that will be added by the logic we have*/ if (dataPointsArray[0] === minVal) {
+        dataPointsArray.push(minVal + val);
+    }
+    if (minVal < 0 && maxVal >= 0) {
+        while(dataPointsArray[dataPointsArray.length - 1] > minVal){
+            dataPointsArray.push(dataPointsArray[dataPointsArray.length - 1] - val);
+        }
+        dataPointsArray.reverse();
+    }
+    while(dataPointsArray[dataPointsArray.length - 1] < maxVal){
+        dataPointsArray.push(dataPointsArray[dataPointsArray.length - 1] + val);
+    }
+    return dataPointsArray;
+}
+function createYAxis(yAxisParams, isRtl, axisData, chartType, barWidth, isIntegralDataset, useSecondaryYScale = false, roundedTicks = false) {
+    switch(chartType){
+        case 6:
+            return createYAxisForHorizontalBarChartWithAxis(yAxisParams, isRtl, axisData, barWidth);
+        default:
+            return createYAxisForOtherCharts(yAxisParams, isRtl, axisData, isIntegralDataset, chartType, useSecondaryYScale, roundedTicks);
+    }
+}
+function createYAxisForHorizontalBarChartWithAxis(yAxisParams, isRtl, axisData, barWidth) {
+    const { yMinMaxValues = {
+        startValue: 0,
+        endValue: 0
+    }, yAxisElement = null, yMaxValue = 0, yMinValue = 0, containerHeight, margins, tickPadding = 12, maxOfYVal = 0, yAxisTickFormat, yAxisTickCount = 4 } = yAxisParams;
+    // maxOfYVal coming from only area chart and Grouped vertical bar chart(Calculation done at base file)
+    const tempVal = maxOfYVal || yMinMaxValues.endValue;
+    const finalYmax = tempVal > yMaxValue ? tempVal : yMaxValue;
+    const finalYmin = yMinMaxValues.startValue < yMinValue ? 0 : yMinValue;
+    const yAxisScale = (0, _d3scale.scaleLinear)().domain([
+        finalYmin,
+        finalYmax
+    ]).range([
+        containerHeight - margins.bottom,
+        margins.top
+    ]);
+    const axis = isRtl ? (0, _d3axis.axisRight)(yAxisScale) : (0, _d3axis.axisLeft)(yAxisScale);
+    const yAxis = axis.tickPadding(tickPadding).ticks(yAxisTickCount);
+    yAxisTickFormat ? yAxis.tickFormat(yAxisTickFormat) : yAxis.tickFormat((0, _d3format.format)('.2~s'));
+    yAxisElement ? (0, _d3selection.select)(yAxisElement).call(yAxis).selectAll('text').attr('aria-hidden', 'true') : '';
+    return yAxisScale;
+}
+function createYAxisForOtherCharts(yAxisParams, isRtl, axisData, isIntegralDataset, chartType, useSecondaryYScale = false, roundedTicks = false) {
+    const { yMinMaxValues = {
+        startValue: 0,
+        endValue: 0
+    }, yAxisElement = null, yMaxValue = 0, yMinValue = 0, containerHeight, containerWidth, margins, tickPadding = 12, maxOfYVal = 0, yAxisTickFormat, yAxisTickCount = 4, eventAnnotationProps, eventLabelHeight } = yAxisParams;
+    // maxOfYVal coming from only area chart and Grouped vertical bar chart(Calculation done at base file)
+    const tempVal = maxOfYVal || yMinMaxValues.endValue;
+    const finalYmax = tempVal > yMaxValue ? tempVal : yMaxValue;
+    const finalYmin = Math.min(yMinMaxValues.startValue, yMinValue || 0);
+    const domainValues = prepareDatapoints(finalYmax, finalYmin, yAxisTickCount, isIntegralDataset, roundedTicks);
+    let yMin = finalYmin;
+    let yMax = domainValues[domainValues.length - 1];
+    if (chartType === 7) {
+        const yPadding = (yMax - yMin) * 0.1;
+        yMin = yMin - yPadding;
+        yMax = yMax + yPadding;
+    }
+    const yAxisScale = (0, _d3scale.scaleLinear)().domain([
+        domainValues[0],
+        yMax
+    ]).range([
+        containerHeight - margins.bottom,
+        margins.top + (eventAnnotationProps ? eventLabelHeight : 0)
+    ]);
+    const axis = !isRtl && useSecondaryYScale || isRtl && !useSecondaryYScale ? (0, _d3axis.axisRight)(yAxisScale) : (0, _d3axis.axisLeft)(yAxisScale);
+    const yAxis = axis.tickPadding(tickPadding).tickValues(domainValues).tickSizeInner(-(containerWidth - margins.left - margins.right));
+    yAxisTickFormat ? yAxis.tickFormat(yAxisTickFormat) : yAxis.tickFormat((0, _d3format.format)('.2~s'));
+    yAxisElement ? (0, _d3selection.select)(yAxisElement).call(yAxis).selectAll('text').attr('aria-hidden', 'true') : '';
+    axisData.yAxisDomainValues = domainValues;
+    return yAxisScale;
+}
+const createStringYAxis = (yAxisParams, dataPoints, isRtl, chartType, barWidth, culture)=>{
+    switch(chartType){
+        case 6:
+            return createStringYAxisForHorizontalBarChartWithAxis(yAxisParams, dataPoints, isRtl, barWidth, culture);
+        default:
+            return createStringYAxisForOtherCharts(yAxisParams, dataPoints, isRtl);
+    }
+};
+const createStringYAxisForHorizontalBarChartWithAxis = (yAxisParams, dataPoints, isRtl, barWidth, culture)=>{
+    const { containerHeight, tickPadding = 12, margins, yAxisTickFormat, yAxisElement } = yAxisParams;
+    const yAxisScale = (0, _d3scale.scaleBand)().domain(dataPoints).range([
+        containerHeight - margins.bottom - barWidth / 2,
+        margins.top + barWidth / 2
+    ]);
+    const axis = isRtl ? (0, _d3axis.axisRight)(yAxisScale) : (0, _d3axis.axisLeft)(yAxisScale);
+    const yAxis = axis.tickPadding(tickPadding).ticks(dataPoints);
+    if (yAxisTickFormat) {
+        yAxis.tickFormat(yAxisTickFormat);
+    }
+    yAxisElement ? (0, _d3selection.select)(yAxisElement).call(yAxis).selectAll('text') : '';
+    return yAxisScale;
+};
+const createStringYAxisForOtherCharts = (yAxisParams, dataPoints, isRtl)=>{
+    const { containerHeight, tickPadding = 12, margins, yAxisTickFormat, yAxisElement, yAxisPadding = 0 } = yAxisParams;
+    const yAxisScale = (0, _d3scale.scaleBand)().domain(dataPoints).range([
+        containerHeight - margins.bottom,
+        margins.top
+    ]).padding(yAxisPadding);
+    const axis = isRtl ? (0, _d3axis.axisRight)(yAxisScale) : (0, _d3axis.axisLeft)(yAxisScale);
+    const yAxis = axis.tickPadding(tickPadding).tickValues(dataPoints).tickSize(0);
+    if (yAxisTickFormat) {
+        yAxis.tickFormat(yAxisTickFormat);
+    }
+    yAxisElement ? (0, _d3selection.select)(yAxisElement).call(yAxis).selectAll('text') : '';
+    return yAxisScale;
+};
+function calloutData(values) {
+    let combinedResult = [];
+    values.forEach((line)=>{
+        const elements = line.data.filter((point)=>!point.hideCallout).map((point)=>{
+            return {
+                ...point,
+                legend: line.legend,
+                color: line.color,
+                index: line.index
+            };
+        });
+        combinedResult = combinedResult.concat(elements);
+    });
+    const xValToDataPoints = {};
+    combinedResult.forEach((ele)=>{
+        const xValue = ele.x instanceof Date ? ele.x.getTime() : ele.x;
+        if (xValue in xValToDataPoints) {
+            xValToDataPoints[xValue].push({
+                legend: ele.legend,
+                y: ele.y,
+                color: ele.color,
+                xAxisCalloutData: ele.xAxisCalloutData,
+                yAxisCalloutData: ele.yAxisCalloutData,
+                callOutAccessibilityData: ele.callOutAccessibilityData,
+                index: ele.index
+            });
+        } else {
+            xValToDataPoints[xValue] = [
+                {
+                    legend: ele.legend,
+                    y: ele.y,
+                    color: ele.color,
+                    xAxisCalloutData: ele.xAxisCalloutData,
+                    yAxisCalloutData: ele.yAxisCalloutData,
+                    callOutAccessibilityData: ele.callOutAccessibilityData,
+                    index: ele.index
+                }
+            ];
+        }
+    });
+    const result = Object.keys(xValToDataPoints).map((xValue)=>{
+        const originalXValue = isNaN(Number(xValue)) ? xValue : Number(xValue);
+        return {
+            x: originalXValue,
+            values: xValToDataPoints[xValue]
+        };
+    });
+    return result;
+}
+function getUnique(arr, comp) {
+    const unique = arr // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .map((e)=>e[comp]) // store the keys of the unique objects
+    .map((e, i, final)=>final.indexOf(e) === i && i) // eliminate the dead keys & store unique objects
+    .filter((e)=>arr[e]).map((e)=>arr[e]);
+    return unique;
+}
+function silceOrAppendToArray(array, value) {
+    const pos = array.indexOf(value);
+    if (pos === -1) {
+        return [
+            ...array,
+            value
+        ];
+    } else {
+        return array.slice(0, pos).concat(array.slice(pos + 1));
+    }
+}
+function createWrapOfXLabels(wrapLabelProps) {
+    const { node, xAxis, noOfCharsToTruncate, showXAxisLablesTooltip } = wrapLabelProps;
+    if (node === null) {
+        return;
+    }
+    const axisNode = (0, _d3selection.select)(node).call(xAxis);
+    let removeVal = 0;
+    const width = 10;
+    const arr = [];
+    axisNode.selectAll('.tick text').each(function() {
+        const text = (0, _d3selection.select)(this);
+        const totalWord = text.text();
+        const truncatedWord = `${text.text().slice(0, noOfCharsToTruncate)}...`;
+        const totalWordLength = text.text().length;
+        const words = text.text().split(/\s+/).reverse();
+        arr.push(words.length);
+        let word = '';
+        let line = [];
+        let lineNumber = 0;
+        const lineHeight = 1.1; // ems
+        const y = text.attr('y');
+        const dy = parseFloat(text.attr('dy'));
+        let tspan = text.text(null).append('tspan').attr('x', 0).attr('y', y).attr('id', 'BaseSpan').attr('dy', dy + 'em').attr('data-', totalWord);
+        if (showXAxisLablesTooltip && totalWordLength > noOfCharsToTruncate) {
+            tspan = text.append('tspan').attr('id', 'showDots').attr('x', 0).attr('y', y).attr('dy', ++lineNumber * lineHeight + dy + 'em').text(truncatedWord);
+        } else if (showXAxisLablesTooltip && totalWordLength <= noOfCharsToTruncate) {
+            tspan = text.append('tspan').attr('id', 'LessLength').attr('x', 0).attr('y', y).attr('dy', ++lineNumber * lineHeight + dy + 'em').text(totalWord);
+        } else {
+            while(word = words.pop()){
+                line.push(word);
+                tspan.text(line.join(' '));
+                if (tspan.node().getComputedTextLength() > width && line.length > 1) {
+                    line.pop();
+                    tspan.text(line.join(' '));
+                    line = [
+                        word
+                    ];
+                    tspan = text.append('tspan').attr('id', 'WordBreakId').attr('x', 0).attr('y', y).attr('dy', ++lineNumber * lineHeight + dy + 'em').text(word);
+                }
+            }
+            const maxDigit = Math.max(...arr);
+            let maxHeight = 12; // intial value to render corretly first time
+            axisNode.selectAll('text').each(()=>{
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const outerHTMLElement = document.getElementById('WordBreakId');
+                const BoxCordinates = outerHTMLElement && outerHTMLElement.getBoundingClientRect();
+                const boxHeight = BoxCordinates && BoxCordinates.height;
+                if (boxHeight > maxHeight) {
+                    maxHeight = boxHeight;
+                }
+            });
+            // If we take directly maxDigit * maxheight, then it will show more height between x axis tick values and bottom.
+            // To avoid this, reducing maxDigit value by removing some digit based on legth of word.
+            let removeDigit = 4;
+            if (maxDigit <= 2) {
+                removeDigit = 1;
+            } else if (maxDigit > 2 && maxDigit <= 6) {
+                removeDigit = 2;
+            } else if (maxDigit > 6 && maxDigit <= 9) {
+                removeDigit = 3;
+            }
+            removeVal = (maxDigit - removeDigit) * maxHeight;
+        }
+    });
+    return removeVal > 0 ? removeVal : 0;
+}
+function createYAxisLabels(node, yAxis, noOfCharsToTruncate, truncateLabel, xValue, isRtl) {
+    if (node === null) {
+        return;
+    }
+    let tickIndex = 0;
+    const axisNode = (0, _d3selection.select)(node).call(yAxis);
+    axisNode.selectAll('.tick text').each(function() {
+        const text = (0, _d3selection.select)(this);
+        const totalWord = text.text();
+        const truncatedWord = isRtl ? `...${text.text().slice(0, noOfCharsToTruncate)}` : `${text.text().slice(0, noOfCharsToTruncate)}...`;
+        const totalWordLength = text.text().length;
+        const padding = truncateLabel ? 1.5 : 1; // ems
+        const y = text.attr('y');
+        const x = text.attr('x');
+        const dy = parseFloat(text.attr('dy'));
+        const dx = 0;
+        const uid = tickIndex++;
+        text.text(null).append('tspan').attr('x', x).attr('y', y).attr('id', `BaseSpan-${uid}`).attr('dy', dy + 'em').attr('data-', totalWord);
+        if (truncateLabel && totalWordLength > noOfCharsToTruncate) {
+            text.append('tspan').attr('id', `showDots-${uid}`).attr('x', isRtl ? 0 : x).attr('y', y).attr('dy', dy).attr('dx', padding + dx + 'em').text(truncatedWord);
+        } else {
+            text.attr('text-align', 'start').append('tspan').attr('id', `LessLength-${uid}`).attr('x', isRtl ? 0 : x).attr('y', y).attr('dx', padding + dx + 'em').text(totalWord);
+        }
+    });
+}
+const wrapContent = (content, id, maxWidth)=>{
+    const textElement = (0, _d3selection.select)(`#${id}`);
+    textElement.text(content);
+    if (!textElement.node()) {
+        return false;
+    }
+    let isOverflowing = false;
+    let textLength = textElement.node().getComputedTextLength();
+    while(textLength > maxWidth && content.length > 0){
+        content = content.slice(0, -1);
+        textElement.text(content + '...');
+        isOverflowing = true;
+        textLength = textElement.node().getComputedTextLength();
+    }
+    return isOverflowing;
+};
+const calculateLongestLabelWidth = (labels, query = 'none')=>{
+    let maxLabelWidth = 0;
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    if (ctx) {
+        const axisText = document.querySelector(query);
+        if (axisText) {
+            const styles = window.getComputedStyle(axisText, null);
+            const fontWeight = styles.getPropertyValue('font-weight');
+            const fontSize = styles.getPropertyValue('font-size');
+            const fontFamily = styles.getPropertyValue('font-family');
+            ctx.font = `${fontWeight} ${fontSize} ${fontFamily}`;
+        } else {
+            ctx.font = '600 10px "Segoe UI"';
+        }
+        labels.forEach((label)=>{
+            maxLabelWidth = Math.max(ctx.measureText(label.toString()).width, maxLabelWidth);
+        });
+    }
+    return maxLabelWidth;
+};
+function tooltipOfXAxislabels(xAxistooltipProps) {
+    const { tooltipCls, xAxis, id } = xAxistooltipProps;
+    if (xAxis === null) {
+        return null;
+    }
+    const div = (0, _d3selection.select)('body').append('div').attr('id', id).attr('class', tooltipCls).style('opacity', 0);
+    const aa = xAxis.selectAll('#BaseSpan')._groups[0];
+    const baseSpanLength = aa && Object.keys(aa).length;
+    const originalDataArray = [];
+    for(let i = 0; i < baseSpanLength; i++){
+        const originalData = aa[i].dataset && Object.values(aa[i].dataset)[0];
+        originalDataArray.push(originalData);
+    }
+    const tickObject = xAxis.selectAll('.tick')._groups[0];
+    const tickObjectLength = tickObject && Object.keys(tickObject).length;
+    for(let i = 0; i < tickObjectLength; i++){
+        const d1 = tickObject[i];
+        (0, _d3selection.select)(d1) // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .on('mouseover', (event, d)=>{
+            div.style('opacity', 0.9);
+            div.html(originalDataArray[i]).style('left', event.pageX + 'px').style('top', event.pageY - 28 + 'px');
+        }).on('mouseout', (d)=>{
+            div.style('opacity', 0);
+        });
+    }
+}
+function getXAxisType(points) {
+    let isXAxisDateType = false;
+    if (points && points.length > 0) {
+        points.forEach((chartData)=>{
+            if (chartData.data.length > 0) {
+                isXAxisDateType = chartData.data[0].x instanceof Date;
+                return;
+            }
+        });
+    }
+    return isXAxisDateType;
+}
+function domainRangeOfNumericForAreaChart(points, margins, width, isRTL) {
+    const xMin = (0, _d3array.min)(points, (point)=>{
+        return (0, _d3array.min)(point.data, (item)=>item.x);
+    });
+    const xMax = (0, _d3array.max)(points, (point)=>{
+        return (0, _d3array.max)(point.data, (item)=>{
+            return item.x;
+        });
+    });
+    const rStartValue = margins.left;
+    const rEndValue = width - margins.right;
+    return isRTL ? {
+        dStartValue: xMax,
+        dEndValue: xMin,
+        rStartValue,
+        rEndValue
+    } : {
+        dStartValue: xMin,
+        dEndValue: xMax,
+        rStartValue,
+        rEndValue
+    };
+}
+function domainRangeOfNumericForScatterChart(points, margins, width, isRTL) {
+    let xMin = (0, _d3array.min)(points, (point)=>{
+        return (0, _d3array.min)(point.data, (item)=>item.x);
+    });
+    let xMax = (0, _d3array.max)(points, (point)=>{
+        return (0, _d3array.max)(point.data, (item)=>{
+            return item.x;
+        });
+    });
+    const xPadding = (xMax - xMin) * 0.1;
+    xMin = xMin - xPadding;
+    xMax = xMax + xPadding;
+    const rStartValue = margins.left;
+    const rEndValue = width - margins.right;
+    return isRTL ? {
+        dStartValue: xMax,
+        dEndValue: xMin,
+        rStartValue,
+        rEndValue
+    } : {
+        dStartValue: xMin,
+        dEndValue: xMax,
+        rStartValue,
+        rEndValue
+    };
+}
+function domainRangeOfNumericForHorizontalBarChartWithAxis(points, margins, containerWidth, isRTL, shiftX) {
+    const xMax = (0, _d3array.max)(points, (point)=>point.x);
+    const rMin = isRTL ? margins.left : margins.left + shiftX;
+    const rMax = isRTL ? containerWidth - margins.right - shiftX : containerWidth - margins.right;
+    return isRTL ? {
+        dStartValue: xMax,
+        dEndValue: 0,
+        rStartValue: rMin,
+        rEndValue: rMax
+    } : {
+        dStartValue: 0,
+        dEndValue: xMax,
+        rStartValue: rMin,
+        rEndValue: rMax
+    };
+}
+function domainRangeOfXStringAxis(margins, width, isRTL) {
+    const rMin = margins.left;
+    const rMax = width - margins.right;
+    return isRTL ? {
+        dStartValue: 0,
+        dEndValue: 0,
+        rStartValue: rMax,
+        rEndValue: rMin
+    } : {
+        dStartValue: 0,
+        dEndValue: 0,
+        rStartValue: rMin,
+        rEndValue: rMax
+    };
+}
+function domainRangeOfVSBCNumeric(points, margins, width, isRTL, barWidth) {
+    const xMin = (0, _d3array.min)(points, (point)=>point.x);
+    const xMax = (0, _d3array.max)(points, (point)=>point.x);
+    const rMax = margins.left;
+    const rMin = width - margins.right;
+    return isRTL ? {
+        dStartValue: xMax,
+        dEndValue: xMin,
+        rStartValue: rMax,
+        rEndValue: rMin
+    } : {
+        dStartValue: xMin,
+        dEndValue: xMax,
+        rStartValue: rMax,
+        rEndValue: rMin
+    };
+}
+function domainRangeOfDateForAreaLineVerticalBarChart(points, margins, width, isRTL, tickValues = [], chartType, barWidth) {
+    let sDate;
+    let lDate;
+    if (chartType === 0 || chartType === 1) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        sDate = (0, _d3array.min)(points, (point)=>{
+            return (0, _d3array.min)(point.data, (item)=>{
+                return item.x;
+            });
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        lDate = (0, _d3array.max)(points, (point)=>{
+            return (0, _d3array.max)(point.data, (item)=>{
+                return item.x;
+            });
+        });
+        // Need to draw graph with given small and large date
+        // (Which Involves customization of date axis tick values)
+        // That may be Either from given graph data or from prop 'tickValues' date values.
+        // So, Finding smallest and largest dates
+        sDate = (0, _d3array.min)([
+            ...tickValues,
+            sDate
+        ]);
+        lDate = (0, _d3array.max)([
+            ...tickValues,
+            lDate
+        ]);
+    } else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        sDate = (0, _d3array.min)(points, (point)=>point.x);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        lDate = (0, _d3array.max)(points, (point)=>point.x);
+    }
+    const rStartValue = margins.left;
+    const rEndValue = width - margins.right;
+    return isRTL ? {
+        dStartValue: lDate,
+        dEndValue: sDate,
+        rStartValue,
+        rEndValue
+    } : {
+        dStartValue: sDate,
+        dEndValue: lDate,
+        rStartValue,
+        rEndValue
+    };
+}
+function domainRangeOfDateForScatterChart(points, margins, width, isRTL, tickValues = []) {
+    let sDate;
+    let lDate;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sDate = (0, _d3array.min)(points, (point)=>{
+        return (0, _d3array.min)(point.data, (item)=>{
+            return item.x;
+        });
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    lDate = (0, _d3array.max)(points, (point)=>{
+        return (0, _d3array.max)(point.data, (item)=>{
+            return item.x;
+        });
+    });
+    const xPadding = (lDate.getTime() - sDate.getTime()) * 0.1;
+    sDate = new Date(sDate.getTime() - xPadding);
+    lDate = new Date(lDate.getTime() + xPadding);
+    // Need to draw graph with given small and large date
+    // (Which Involves customization of date axis tick values)
+    // That may be Either from given graph data or from prop 'tickValues' date values.
+    // So, Finding smallest and largest dates
+    sDate = (0, _d3array.min)([
+        ...tickValues,
+        sDate
+    ]);
+    lDate = (0, _d3array.max)([
+        ...tickValues,
+        lDate
+    ]);
+    const rStartValue = margins.left;
+    const rEndValue = width - margins.right;
+    return isRTL ? {
+        dStartValue: lDate,
+        dEndValue: sDate,
+        rStartValue,
+        rEndValue
+    } : {
+        dStartValue: sDate,
+        dEndValue: lDate,
+        rStartValue,
+        rEndValue
+    };
+}
+function domainRageOfVerticalNumeric(points, margins, containerWidth, isRTL, barWidth) {
+    const xMax = (0, _d3array.max)(points, (point)=>point.x);
+    const xMin = (0, _d3array.min)(points, (point)=>point.x);
+    const rMin = margins.left;
+    const rMax = containerWidth - margins.right;
+    return isRTL ? {
+        dStartValue: xMax,
+        dEndValue: xMin,
+        rStartValue: rMin,
+        rEndValue: rMax
+    } : {
+        dStartValue: xMin,
+        dEndValue: xMax,
+        rStartValue: rMin,
+        rEndValue: rMax
+    };
+}
+function getDomainNRangeValues(points, margins, width, chartType, isRTL, xAxisType, barWidth, tickValues, shiftX) {
+    let domainNRangeValue;
+    if (xAxisType === 0) {
+        switch(chartType){
+            case 0:
+            case 1:
+                domainNRangeValue = domainRangeOfNumericForAreaChart(points, margins, width, isRTL);
+                break;
+            case 3:
+                domainNRangeValue = domainRangeOfVSBCNumeric(points, margins, width, isRTL, barWidth);
+                break;
+            case 2:
+                domainNRangeValue = domainRageOfVerticalNumeric(points, margins, width, isRTL, barWidth);
+                break;
+            case 6:
+                domainNRangeValue = domainRangeOfNumericForHorizontalBarChartWithAxis(points, margins, width, isRTL, shiftX);
+                break;
+            case 7:
+                domainNRangeValue = domainRangeOfNumericForScatterChart(points, margins, width, isRTL);
+                break;
+            default:
+                domainNRangeValue = {
+                    dStartValue: 0,
+                    dEndValue: 0,
+                    rStartValue: 0,
+                    rEndValue: 0
+                };
+        }
+    } else if (xAxisType === 1) {
+        switch(chartType){
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+                domainNRangeValue = domainRangeOfDateForAreaLineVerticalBarChart(points, margins, width, isRTL, tickValues, chartType, barWidth);
+                break;
+            case 7:
+                domainNRangeValue = domainRangeOfDateForScatterChart(points, margins, width, isRTL, tickValues);
+                break;
+            default:
+                domainNRangeValue = {
+                    dStartValue: 0,
+                    dEndValue: 0,
+                    rStartValue: 0,
+                    rEndValue: 0
+                };
+        }
+    } else {
+        // String Axis type
+        switch(chartType){
+            case 3:
+            case 4:
+            case 2:
+            case 5:
+            case 7:
+                domainNRangeValue = domainRangeOfXStringAxis(margins, width, isRTL);
+                break;
+            default:
+                domainNRangeValue = {
+                    dStartValue: 0,
+                    dEndValue: 0,
+                    rStartValue: 0,
+                    rEndValue: 0
+                };
+        }
+    }
+    return domainNRangeValue;
+}
+function findNumericMinMaxOfY(points) {
+    const yMax = (0, _d3array.max)(points, (point)=>{
+        return (0, _d3array.max)(point.data, (item)=>item.y);
+    });
+    const yMin = (0, _d3array.min)(points, (point)=>{
+        return (0, _d3array.min)(point.data, (item)=>item.y);
+    });
+    return {
+        startValue: yMin,
+        endValue: yMax
+    };
+}
+function findVSBCNumericMinMaxOfY(dataset) {
+    const yMax = (0, _d3array.max)(dataset, (point)=>point.y);
+    const yMin = (0, _d3array.min)(dataset, (point)=>point.y);
+    return {
+        startValue: yMin,
+        endValue: yMax
+    };
+}
+function findVerticalNumericMinMaxOfY(points) {
+    const yMax = (0, _d3array.max)(points, (point)=>{
+        if (point.lineData !== undefined) {
+            if (point.y > point.lineData.y) {
+                return point.y;
+            } else {
+                return point.lineData.y;
+            }
+        } else {
+            return point.y;
+        }
+    });
+    const yMin = (0, _d3array.min)(points, (point)=>{
+        if (point.lineData !== undefined) {
+            if (point.y < point.lineData.y) {
+                return point.y;
+            } else {
+                return point.lineData.y;
+            }
+        } else {
+            return point.y;
+        }
+    });
+    return {
+        startValue: yMin,
+        endValue: yMax
+    };
+}
+function findHBCWANumericMinMaxOfY(points, yAxisType) {
+    if (yAxisType !== undefined && yAxisType === 0) {
+        const yMax = (0, _d3array.max)(points, (point)=>point.y);
+        const yMin = (0, _d3array.min)(points, (point)=>point.y);
+        return {
+            startValue: yMin,
+            endValue: yMax
+        };
+    }
+    return {
+        startValue: 0,
+        endValue: 0
+    };
+}
+function getMinMaxOfYAxis(points, chartType, yAxisType = 0) {
+    let minMaxValues;
+    switch(chartType){
+        case 0:
+        case 1:
+        case 7:
+            minMaxValues = findNumericMinMaxOfY(points);
+            break;
+        case 3:
+            minMaxValues = findVSBCNumericMinMaxOfY(points);
+            break;
+        case 2:
+            minMaxValues = findVerticalNumericMinMaxOfY(points);
+            break;
+        case 6:
+            minMaxValues = findHBCWANumericMinMaxOfY(points, yAxisType);
+            break;
+        default:
+            minMaxValues = {
+                startValue: 0,
+                endValue: 0
+            };
+    }
+    return minMaxValues;
+}
+const getTypeOfAxis = (p, isXAxis)=>{
+    if (isXAxis) {
+        switch(typeof p){
+            case 'string':
+                return 2;
+            case 'number':
+                return 0;
+            default:
+                return 1;
+        }
+    } else {
+        switch(typeof p){
+            case 'string':
+                return 2;
+            case 'number':
+                return 0;
+            default:
+                return 1;
+        }
+    }
+};
+var Points;
+(function(Points) {
+    Points[Points["circle"] = 0] = "circle";
+    Points[Points["square"] = 1] = "square";
+    Points[Points["triangle"] = 2] = "triangle";
+    Points[Points["diamond"] = 3] = "diamond";
+    Points[Points["pyramid"] = 4] = "pyramid";
+    Points[Points["hexagon"] = 5] = "hexagon";
+    Points[Points["pentagon"] = 6] = "pentagon";
+    Points[Points["octagon"] = 7] = "octagon";
+})(Points || (Points = {}));
+var CustomPoints;
+(function(CustomPoints) {
+    CustomPoints[CustomPoints["dottedLine"] = 0] = "dottedLine";
+})(CustomPoints || (CustomPoints = {}));
+const pointTypes = {
+    [0]: {
+        widthRatio: 1
+    },
+    [1]: {
+        widthRatio: 1
+    },
+    [2]: {
+        widthRatio: 1
+    },
+    [3]: {
+        widthRatio: 1
+    },
+    [4]: {
+        widthRatio: 1
+    },
+    [5]: {
+        widthRatio: 2
+    },
+    [6]: {
+        widthRatio: 1.168
+    },
+    [7]: {
+        widthRatio: 2.414
+    }
+};
+const getAccessibleDataObject = (accessibleData, role = 'text', isDataFocusable = true)=>{
+    accessibleData = accessibleData !== null && accessibleData !== void 0 ? accessibleData : {};
+    return {
+        role,
+        'data-is-focusable': isDataFocusable,
+        'aria-label': accessibleData.ariaLabel,
+        'aria-labelledby': accessibleData.ariaLabelledBy,
+        'aria-describedby': accessibleData.ariaDescribedBy
+    };
+};
+const convertToLocaleString = (data, culture)=>{
+    if (data === undefined || data === null || Number.isNaN(data)) {
+        return data;
+    }
+    culture = culture || undefined;
+    if (typeof data === 'number') {
+        return data.toLocaleString(culture);
+    } else if (typeof data === 'string' && !isNaN(Number(data))) {
+        const num = Number(data);
+        return num.toLocaleString(culture);
+    } else if (data instanceof Date) {
+        return data.toLocaleDateString(culture);
+    }
+    return data;
+};
+function rotateXAxisLabels(rotateLabelProps) {
+    const { node, xAxis } = rotateLabelProps;
+    if (node === null || xAxis === null) {
+        return;
+    }
+    let maxHeight = 0;
+    const xAxisTranslations = [];
+    (0, _d3selection.select)(node).call(xAxis).selectAll('.tick').each(function() {
+        const translateValue = this.getAttribute('transform');
+        if ((translateValue === null || translateValue === void 0 ? void 0 : translateValue.indexOf('rotate')) === -1) {
+            const translatePair = translateValue.substring(translateValue.indexOf('(') + 1, translateValue.indexOf(')')).split(',');
+            if (translatePair.length === 2) {
+                xAxisTranslations.push(translatePair[0]);
+                this.setAttribute('transform', `translate(${translatePair[0]},0)rotate(-45)`);
+            }
+        }
+        const BoxCordinates = this.getBoundingClientRect();
+        const boxHeight = BoxCordinates && BoxCordinates.height;
+        if (boxHeight > maxHeight) {
+            maxHeight = boxHeight;
+        }
+    });
+    let idx = 0;
+    (0, _d3selection.select)(node).call(xAxis).selectAll('.tick').each(function() {
+        if (xAxisTranslations.length > idx) {
+            this.setAttribute('transform', `translate(${xAxisTranslations[idx]},${maxHeight / 2})rotate(-45)`); // Translate y by max height/2
+            idx += 1;
+        }
+    });
+    return Math.floor(maxHeight / 1.414); // Compute maxHeight/tanInverse(45) to get the vertical height of labels.
+}
+function wrapTextInsideDonut(selectorClass, maxWidth) {
+    let idx = 0;
+    (0, _d3selection.selectAll)(`.${selectorClass}`).each(function() {
+        const text = (0, _d3selection.select)(this);
+        const words = text.text().split(/\s+/).reverse();
+        let word = '';
+        let line = [];
+        let lineNumber = 0;
+        const lineHeight = 1.1; // ems
+        const y = text.attr('y');
+        let tspan = text.text(null).append('tspan').attr('id', `WordBreakId-${idx}-${lineNumber}`).attr('x', 0).attr('y', y).attr('dy', lineNumber++ * lineHeight + 'em');
+        while(word = words.pop()){
+            line.push(word);
+            tspan.text(line.join(' ') + ' ');
+            if (tspan.node().getComputedTextLength() > maxWidth && line.length > 1) {
+                line.pop();
+                tspan.text(line.join(' ') + ' ');
+                line = [
+                    word
+                ];
+                tspan = text.append('tspan').attr('id', `WordBreakId-${idx}-${lineNumber}`).attr('x', 0).attr('y', y).attr('dy', lineNumber++ * lineHeight + 'em').text(word);
+            }
+        }
+        idx += 1;
+    });
+}
+function formatValueWithSIPrefix(value) {
+    let specifier;
+    if (value < 1000) {
+        specifier = '.2~'; // upto 2 decimal places without insignificant trailing zeros
+    } else {
+        specifier = '.1'; // upto 1 decimal place
+    }
+    return (0, _d3format.formatPrefix)(specifier, value)(value);
+}
+const DEFAULT_BAR_WIDTH = 16;
+const MIN_BAR_WIDTH = 1;
+const getBarWidth = (barWidthProp, maxBarWidthProp, adjustedValue = DEFAULT_BAR_WIDTH)=>{
+    let barWidth;
+    if (typeof barWidthProp === 'number') {
+        barWidth = barWidthProp;
+    } else if (barWidthProp === 'default' || typeof barWidthProp === 'undefined') {
+        barWidth = Math.min(adjustedValue, DEFAULT_BAR_WIDTH);
+    } else {
+        barWidth = adjustedValue;
+    }
+    if (typeof maxBarWidthProp === 'number') {
+        barWidth = Math.min(barWidth, maxBarWidthProp);
+    }
+    barWidth = Math.max(barWidth, MIN_BAR_WIDTH);
+    return barWidth;
+};
+const getScalePadding = (prop, shorthandProp, defaultValue = 0)=>{
+    let padding = typeof prop === 'number' ? prop : typeof shorthandProp === 'number' ? shorthandProp : defaultValue;
+    padding = Math.max(0, Math.min(padding, 1));
+    return padding;
+};
+const isScalePaddingDefined = (prop, shorthandProp)=>{
+    return typeof prop === 'number' || typeof shorthandProp === 'number';
+};
+function findIndex(array, cb, fromIndex = 0) {
+    let index = -1;
+    for(let i = fromIndex; array && i < array.length; i++){
+        if (cb(array[i], i)) {
+            index = i;
+            break;
+        }
+    }
+    return index;
+}
+function find(array, cb) {
+    let index = findIndex(array, cb);
+    if (index < 0) {
+        return undefined;
+    }
+    return array[index];
+}
+const HighContrastSelector = '@media screen and (-ms-high-contrast: active), screen and (forced-colors: active)';
+const HighContrastSelectorWhite = '@media screen and (-ms-high-contrast: black-on-white), screen and (forced-colors: active) and (prefers-color-scheme: light)';
+const HighContrastSelectorBlack = '@media screen and (-ms-high-contrast: white-on-black), screen and (forced-colors: active) and (prefers-color-scheme: dark)';
+const formatDate = (date, useUTC)=>{
+    const timeFormat = useUTC ? _d3timeformat.utcFormat : _d3timeformat.timeFormat;
+    return timeFormat('%-e %b %Y, %H:%M')(date) + (useUTC ? ' GMT' : '');
+};
+function areArraysEqual(arr1, arr2) {
+    if (arr1 === arr2 || !arr1 && !arr2) {
+        return true;
+    }
+    if (!arr1 || !arr2 || arr1.length !== arr2.length) {
+        return false;
+    }
+    for(let i = 0; i < arr1.length; i++){
+        if (arr1[i] !== arr2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+const cssVarRegExp = /var\((--[a-zA-Z0-9\-]+)\)/g;
+function resolveCSSVariables(chartContainer, styleRules) {
+    const containerStyles = getComputedStyle(chartContainer);
+    return styleRules.replace(cssVarRegExp, (match, group1)=>{
+        return containerStyles.getPropertyValue(group1);
+    });
+}
+function getSecureProps(props = {}) {
+    const { dangerouslySetInnerHTML, ...result } = props;
+    return result;
+}
+function getCurveFactory(curve, defaultFactory = _d3shape.curveLinear) {
+    if (typeof curve === 'function') {
+        return curve;
+    }
+    switch(curve){
+        case 'linear':
+            return _d3shape.curveLinear;
+        case 'natural':
+            return _d3shape.curveNatural;
+        case 'step':
+            return _d3shape.curveStep;
+        case 'stepAfter':
+            return _d3shape.curveStepAfter;
+        case 'stepBefore':
+            return _d3shape.curveStepBefore;
+        default:
+            return defaultFactory;
+    }
+}