@datarailsshared/dr_renderer 1.3.57 → 1.4.5

package/tests/highcharts_renderer.test.js

@@ -8,6 +8,7 @@ import addInDynamicRanges from './mock/add-in-dynamic-ranges.json';
 import widgets from './mock/widgets.json';
 import initPivotTable from "../src/pivottable";
 import initDRPivotTable from "../src/dr_pivottable";
+import valueFormatter from "../src/value.formatter";
 import { DrGaugeChart, GAUGE_OPTIONS_DEFAULT } from "../src/charts/dr_gauge_chart";
 
 const mockDrChartRender = jest.fn();
@@ -68,6 +69,8 @@ let _document = document;
 let Highcharts;
 
 describe('highcharts_renderer', () => {
+    let getAggregatorPercentageValueIfRequiredMock;
+
     beforeAll(() => {
         Highcharts = {
             charts: [{
@@ -92,6 +95,12 @@ describe('highcharts_renderer', () => {
 
         highchartsRenderer = getHighchartsRenderer($, _document, Highcharts, lodash.cloneDeep(DEFAULT_USER_COLORS), highchartsRenderer,
             DataFormatter, lodash, moment, true);
+
+        getAggregatorPercentageValueIfRequiredMock = jest.spyOn(valueFormatter, 'getAggregatorPercentageValueIfRequired').mockImplementation(() => null);
+    });
+
+    afterAll(() => {
+        getAggregatorPercentageValueIfRequiredMock.mockRestore();
     });
 
     describe('Function filterFloat', () => {
@@ -511,19 +520,574 @@ describe('highcharts_renderer', () => {
     });
 
     describe('function defaultDataLabelFormatter', () => {
+        let mockPivotData;
         let funcContext;
         let opts;
 
         beforeEach(() => {
             highchartsRenderer.enabledNewWidgetValueFormatting = false;
-            funcContext = { y: '12345.678' };
-            opts = {}
+            highchartsRenderer.delimer = ' , ';
+
+            funcContext = {
+                y: 12345.678,
+                series: {
+                    name: 'TestSeries',
+                    userOptions: {},
+                    options: {}
+                },
+                point: {
+                    name: 'TestPoint',
+                    options: {}
+                }
+            };
+            opts = {};
+
+            mockPivotData = {
+                rowAttrs: ['row1'],
+                colAttrs: ['col1'],
+                getColKeys: jest.fn(() => [['col1'], ['col2']]),
+                getRowKeys: jest.fn(() => [['row1'], ['row2']]),
+                getAggregator: jest.fn(() => ({
+                    value: () => 1000
+                }))
+            };
+
+            spyOn(highchartsRenderer, 'getSeriesNameInFormatterContext').and.returnValue('TestSeries');
+            spyOn(highchartsRenderer, 'getColsInFormatterContext').and.returnValue(['col1']);
+            spyOn(highchartsRenderer, 'getOthersName').and.returnValue('Others');
+            spyOn(highchartsRenderer, 'getDrOthersInAxisState').and.returnValue({});
+            spyOn(highchartsRenderer, 'transformRowsAndColsForBreakdown').and.returnValue({
+                rows: ['row1'],
+                cols: ['col1']
+            });
+            spyOn(highchartsRenderer, 'replaceDrOthersKeys');
+            spyOn(highchartsRenderer, 'selfStartsWith').and.returnValue(false);
+            spyOn(highchartsRenderer, 'isChartWithMultiValues').and.returnValue(true);
+
+            global.$ = {
+                pivotUtilities: {
+                    getFormattedNumber: jest.fn(() => '1,234.56')
+                }
+            };
         });
 
-        it('should return local string if there are no pivotData', () => {
-            let fn = highchartsRenderer.defaultDataLabelFormatter(null, {})
-            let result = fn.call(funcContext)
-            expect(result).toBe('12,345.678');
+        describe('No pivotData is provided', () => {
+            it('should return formatted number as local string', () => {
+                let fn = highchartsRenderer.defaultDataLabelFormatter(null, {});
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should handle unit sign removal when labelOptions are provided', () => {
+                const labelOptions = { useUnitAbbreviation: false };
+                opts = { chartOptions: { label: labelOptions } };
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(null, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+        });
+
+        describe('pivotData is provided', () => {
+            beforeEach(() => {
+                funcContext.y = 1234.56;
+            });
+
+            it('should format value using pivot data aggregator when show_value is true', () => {
+                opts = { chartOptions: { label: { show_value: true } } };
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(highchartsRenderer.getSeriesNameInFormatterContext).toHaveBeenCalledWith(funcContext);
+                expect(highchartsRenderer.getColsInFormatterContext).toHaveBeenCalledWith(funcContext);
+                expect(mockPivotData.getAggregator).toHaveBeenCalled();
+                expect(result).toBe('1,234.56');
+            });
+
+            it('should return empty string when show_value is false and not drill-down pie', () => {
+                opts = { chartOptions: { label: { show_value: false } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('');
+            });
+
+            it('should handle empty row attributes', () => {
+                mockPivotData.rowAttrs = [];
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('1,234.56');
+            });
+
+            it('should handle totalSeries className', () => {
+                funcContext.series.options.className = 'totalSeries';
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('1,234.56');
+            });
+
+            it('should handle trendSeries className', () => {
+                funcContext.series.options.className = 'trendSeries';
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('1,234.56');
+            });
+        });
+
+        describe('Drill-down pie chart scenarios', () => {
+            beforeEach(() => {
+                funcContext.y = 500;
+            });
+
+            it('should handle drill-down pie when series name starts with "Series " and chart does not have multi values', () => {
+                highchartsRenderer.selfStartsWith.and.returnValue(true);
+                highchartsRenderer.getSeriesNameInFormatterContext.and.returnValue('Series 1');
+                highchartsRenderer.isChartWithMultiValues.and.returnValue(false);
+
+                opts = { chartOptions: {} };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts, true);
+                let result = fn.call(funcContext);
+
+                expect(highchartsRenderer.selfStartsWith).toHaveBeenCalledWith('Series 1', 'Series ');
+                expect(highchartsRenderer.isChartWithMultiValues).toHaveBeenCalledWith(mockPivotData);
+                expect(result).toBe('500');
+            });
+
+            it('should handle drill-down pie when is a multi values chart', () => {
+                highchartsRenderer.isChartWithMultiValues.and.returnValue(true);
+
+                opts = { chartOptions: {} };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts, true);
+                let result = fn.call(funcContext);
+
+                expect(highchartsRenderer.isChartWithMultiValues).toHaveBeenCalledWith(mockPivotData);
+                expect(result).toBe('500');
+            });
+
+            it('should use point name for columns when cols is null in drill-down pie', () => {
+                highchartsRenderer.getColsInFormatterContext.and.returnValue(null);
+                funcContext.point.name = 'DrillDownPoint';
+
+                opts = { chartOptions: {} };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts, true);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('500');
+            });
+
+            it('should swap rows and cols for drill-down pie when series name does not start with "Series "', () => {
+                highchartsRenderer.selfStartsWith.and.returnValue(false);
+                highchartsRenderer.getSeriesNameInFormatterContext.and.returnValue('CustomSeries');
+
+                opts = { chartOptions: {} };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts, true);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('500');
+            });
+        });
+
+        describe('Delta column handling', () => {
+            it('should replace variant name when delta column field is series', () => {
+                opts = {
+                    chartOptions: {
+                        label: { show_value: true },
+                        delta_column: {
+                            field: 'series',
+                            name: 'test_variant'
+                        }
+                    }
+                };
+
+                highchartsRenderer.getSeriesNameInFormatterContext.and.returnValue('test_variant' + highchartsRenderer.delimer + 'other');
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should handle variant name matching when series name differs by underscores from delta column name', () => {
+                opts = {
+                    chartOptions: {
+                        label: { show_value: true },
+                        delta_column: {
+                            field: 'series',
+                            name: 'test_variant'
+                        }
+                    }
+                };
+
+                highchartsRenderer.getSeriesNameInFormatterContext.and.returnValue('testvariant' + highchartsRenderer.delimer + 'other');
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+        });
+
+        describe('Label options handling', () => {
+            it('should return raw value when show_out_of_x_axis is true but percentage logic is not triggered', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_x_axis: true
+                        }
+                    }
+                };
+
+                funcContext.y = 250;
+                mockPivotData.getAggregator = jest.fn(() => ({ value: () => 1000 }));
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('250');
+            });
+
+            it('should return raw value when show_out_of_data_series is true but percentage logic is not triggered', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_data_series: true
+                        }
+                    }
+                };
+
+                funcContext.y = 200;
+                mockPivotData.getAggregator = jest.fn(() => ({ value: () => 800 }));
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('200');
+            });
+
+            it('should return raw value when both percentage options are enabled but percentage logic is not triggered', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_x_axis: true,
+                            show_out_of_data_series: true
+                        }
+                    }
+                };
+
+                funcContext.y = 250;
+                let callCount = 0;
+                mockPivotData.getAggregator = jest.fn(() => {
+                    callCount++;
+                    return { value: () => callCount === 1 ? 1000 : 800 };
+                });
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('250');
+            });
+
+            it('should show only percentages without value when show_value is false but percentages are enabled', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: false,
+                            show_out_of_x_axis: true
+                        }
+                    }
+                };
+
+                funcContext.y = 250;
+                mockPivotData.getAggregator = jest.fn(() => ({ value: () => 1000 }));
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('(25%)');
+            });
+
+            it('should not add percentage when value is falsy', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_x_axis: true
+                        }
+                    }
+                };
+
+                funcContext.y = 0;
+                mockPivotData.getAggregator = jest.fn(() => ({ value: () => 1000 }));
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('0');
+            });
+
+            it('should not add percentage when axisTotal is falsy', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_x_axis: true
+                        }
+                    }
+                };
+
+                funcContext.y = 250;
+                mockPivotData.getAggregator = jest.fn(() => ({ value: () => 0 }));
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('250');
+            });
+        });
+
+        describe('Object column handling', () => {
+            it('should extract name property from object columns', () => {
+                highchartsRenderer.getColsInFormatterContext.and.returnValue({ name: 'ObjectColumn' });
+
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+        });
+
+        describe('Column initialization handling', () => {
+            it('should initialize cols to empty array when cols is falsy after array check', () => {
+                spyOn(lodash, 'isArray').and.returnValue(true);
+                highchartsRenderer.getColsInFormatterContext.and.returnValue(null);
+
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+                expect(lodash.isArray).toHaveBeenCalledWith(null);
+            });
+        });
+
+        describe('Waterfall breakdown handling', () => {
+            beforeEach(() => {
+                funcContext.series.options.className = 'waterfallBreakdown';
+            });
+
+            it('should transform rows and cols for waterfall breakdown', () => {
+                opts = { chartOptions: { label: { show_value: true } } };
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(highchartsRenderer.transformRowsAndColsForBreakdown).toHaveBeenCalled();
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should return raw value for waterfall breakdown when show_out_of_data_series is true but percentage logic is not triggered', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_data_series: true
+                        }
+                    }
+                };
+
+                funcContext.y = 300;
+                mockPivotData.getRowKeys = jest.fn(() => ([['row1'], ['row2']]));
+
+                let callCount = 0;
+                mockPivotData.getAggregator = jest.fn((rows, cols) => {
+                    if (rows.length === 1) return { value: () => 400 };
+                    if (rows.length === 0 && cols.length > 0) return { value: () => 1200 };
+                    return { value: () => 800 };
+                });
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('300');
+            });
+
+            it('should calculate percentage using dataSeriesTotal when axisTotal is falsy (waterfall breakdown)', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: false,
+                            show_out_of_data_series: true
+                        }
+                    }
+                };
+
+                funcContext.y = 200; // value = 200
+                mockPivotData.getRowKeys = jest.fn(() => ([['row1'], ['row2']]));
+
+                let callCount = 0;
+                mockPivotData.getAggregator = jest.fn((rows, cols) => {
+                    callCount++;
+
+                    if (rows.length === 1) {
+                        return { value: () => 400 };
+                    }
+                    if (rows.length === 0 && cols.length > 0) {
+                        return { value: () => 0 };
+                    }
+
+                    return { value: () => 200 };
+                });
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('(25%)');
+            });
+
+            it('should not add percentage when dataSeriesTotal is falsy (non-waterfall breakdown)', () => {
+                funcContext.series.options.className = 'regularSeries';
+
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: false,
+                            show_out_of_data_series: true
+                        }
+                    }
+                };
+
+                funcContext.y = 200;
+
+                mockPivotData.getAggregator = jest.fn((rows, cols) => {
+                    if (cols.length === 0) {
+                        return { value: () => 0 };
+                    }
+                    return { value: () => 200 };
+                });
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('');
+            });
+        });
+
+        describe('Error handling', () => {
+            it('should fallback to basic formatting when aggregator throws error', () => {
+                mockPivotData.getAggregator = jest.fn(() => { throw new Error('Test error'); });
+
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should handle null columns gracefully', () => {
+                highchartsRenderer.getColsInFormatterContext.and.returnValue(null);
+
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should handle empty options gracefully for drill-down pie', () => {
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, {}, true);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+        });
+
+        describe('Unit abbreviation options (fallback behavior)', () => {
+            it('should fallback to raw value formatting when useUnitAbbreviation is false and getFormattedNumber returns abbreviated value', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            useUnitAbbreviation: false
+                        }
+                    }
+                };
+
+                jest.spyOn(global.$.pivotUtilities, 'getFormattedNumber').mockReturnValue('12.5K');
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should fallback to raw value formatting when useUnitAbbreviation is true and getFormattedNumber returns abbreviated value', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            useUnitAbbreviation: true
+                        }
+                    }
+                };
+
+                jest.spyOn(global.$.pivotUtilities, 'getFormattedNumber').mockReturnValue('12.5K');
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should fallback to raw value formatting when getFormattedNumber returns M-abbreviated value regardless of useUnitAbbreviation setting', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            useUnitAbbreviation: false
+                        }
+                    }
+                };
+
+                jest.spyOn(global.$.pivotUtilities, 'getFormattedNumber').mockReturnValue('1.2M');
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+        });
+
+        describe('Others name handling', () => {
+            it('should handle others name replacement', () => {
+                opts = {
+                    total_value_options: { some: 'option' },
+                    chartOptions: { label: { show_value: true } }
+                };
+
+                highchartsRenderer.getOthersName.and.returnValue('CustomOthers');
+                highchartsRenderer.getDrOthersInAxisState.and.returnValue({ cols: true });
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(highchartsRenderer.getOthersName).toHaveBeenCalledWith(opts);
+                expect(highchartsRenderer.getDrOthersInAxisState).toHaveBeenCalledWith(mockPivotData, 'CustomOthers');
+                expect(highchartsRenderer.replaceDrOthersKeys).toHaveBeenCalled();
+                expect(result).toBe('12,345.678');
+            });
         });
     });
 
@@ -1508,7 +2072,7 @@ describe('highcharts_renderer', () => {
                         field: 'series',
                         name: 'TEST_test',
                         same_yaxis: true,
-                        is_percentage: true,
+                        is_percentage: false,
                     }
                 }
             };
@@ -1522,10 +2086,10 @@ describe('highcharts_renderer', () => {
                 highchartsRenderer.updateBackwardCompatibleWidgetOptions(currentOptions, null);
                 expect(currentOptions.comboOptions).toEqual({
                     secondaryAxisSettings: {
-                        name: 'TESTtest',
+                        name: 'Secondary Axis',
                         max: null,
                         min: null,
-                        is_percentage: true
+                        is_percentage: false
                     },
                     seriesOptions: [{
                         series: 'TEST_test',
@@ -2064,17 +2628,20 @@ describe('highcharts_renderer', () => {
                     it('Should return General format if there are no widget_values_format', () => {
                         aggregatorObject.widget_values_format = null;
                         expect(aggregatorObject.format(123.4567, false)).toBe('123.46');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return widget format if it\'s not calculated value', () => {
                         aggregatorObject.widget_values_format = '\"$\"#,###.###';
                         expect(aggregatorObject.format(1123.4567, false)).toBe('$1,123.457');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return calculated value format if it\'s calculated value', () => {
                         aggregator = highchartsRenderer.rhPivotAggregatorSum(arg, widget_values_format, is_graph, render_options, calculated_info);
                         aggregatorObject = aggregator({}, ['Region average'], '');
                         expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions and widget_value_format to equal first seriesOptions format', () => {
@@ -2091,6 +2658,7 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, ['Profit'], '');
                         aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
                         expect(aggregatorObject.format(1123.45678, false)).toBe('$1,123.457');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
                 });
             });
@@ -2265,17 +2833,20 @@ describe('highcharts_renderer', () => {
                     it('Should return General format if there are no widget_values_format', () => {
                         aggregatorObject.widget_values_format = null;
                         expect(aggregatorObject.format(123.4567, false)).toBe('123.46');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return widget format if it\'s not calculated value', () => {
                         aggregatorObject.widget_values_format = '\"$\"#,###.###';
                         expect(aggregatorObject.format(1123.4567, false)).toBe('$1,123.457');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return calculated value format if it\'s calculated value', () => {
                         aggregator = highchartsRenderer.rhPivotCount(arg, widget_values_format, is_graph, render_options, calculated_info);
                         aggregatorObject = aggregator({}, ['Region average'], '');
                         expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions and widget_value_format to equal first seriesOptions format', () => {
@@ -2292,6 +2863,7 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, ['Profit'], '');
                         aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
                         expect(aggregatorObject.format(1123.45678, false)).toBe('$1,123.457');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
                 });
             });
@@ -2424,6 +2996,7 @@ describe('highcharts_renderer', () => {
                     it('Should return widget format if it\'s graph', () => {
                         aggregatorObject.widget_values_format = '\"$\"#,###.###';
                         expect(aggregatorObject.format(2, false)).toBe('$2.000');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return widget format if it\'s only_formats', () => {
@@ -2431,6 +3004,7 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, '', '');
                         aggregatorObject.widget_values_format = '\"$\"#,###.###';
                         expect(aggregatorObject.format(2, true)).toBe('$2.000');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return uniq values if it\'s table and not only_formats', () => {
@@ -2438,6 +3012,7 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, '', '');
                         aggregatorObject.formated_values = ['val1', 'val2'];
                         expect(aggregatorObject.format(aggregatorObject.formated_values, false)).toBe('val1<br>val2');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
                 });
             });
@@ -2616,17 +3191,20 @@ describe('highcharts_renderer', () => {
                     it('Should return General format if there are no widget_values_format', () => {
                         aggregatorObject.widget_values_format = null;
                         expect(aggregatorObject.format(123.4567, false)).toBe('123.46');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return widget format if it\'s not calculated value', () => {
                         aggregatorObject.widget_values_format = '\"$\"#,###.###';
                         expect(aggregatorObject.format(1123.4567, false)).toBe('$1,123.457');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return calculated value format if it\'s calculated value', () => {
                         aggregator = highchartsRenderer.rhPivotAggregatorAverage(arg, widget_values_format, is_graph, render_options, calculated_info);
                         aggregatorObject = aggregator({}, ['Region average'], '');
                         expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions and widget_value_format to equal first seriesOptions format', () => {
@@ -2643,6 +3221,7 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, ['Profit'], '');
                         aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
                         expect(aggregatorObject.format(1123.45678, false)).toBe('$1,123.457');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
                 });
             });
@@ -2818,17 +3397,20 @@ describe('highcharts_renderer', () => {
                     it('Should return General format if there are no widget_values_format', () => {
                         aggregatorObject.widget_values_format = null;
                         expect(aggregatorObject.format(123.4567, false)).toBe('123.46');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return widget format if it\'s not calculated value', () => {
                         aggregatorObject.widget_values_format = '\"$\"#,###.###';
                         expect(aggregatorObject.format(1123.4567, false)).toBe('$1,123.457');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return calculated value format if it\'s calculated value', () => {
                         aggregator = highchartsRenderer.rhPivotAggregatorMin(arg, widget_values_format, is_graph, render_options, calculated_info);
                         aggregatorObject = aggregator({}, ['Region average'], '');
                         expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions and widget_value_format to equal first seriesOptions format', () => {
@@ -2845,6 +3427,7 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, ['Profit'], '');
                         aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
                         expect(aggregatorObject.format(1123.45678, false)).toBe('$1,123.457');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
                 });
             });
@@ -3020,17 +3603,20 @@ describe('highcharts_renderer', () => {
                     it('Should return General format if there are no widget_values_format', () => {
                         aggregatorObject.widget_values_format = null;
                         expect(aggregatorObject.format(123.4567, false)).toBe('123.46');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return widget format if it\'s not calculated value', () => {
                         aggregatorObject.widget_values_format = '\"$\"#,###.###';
                         expect(aggregatorObject.format(1123.4567, false)).toBe('$1,123.457');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('Should return calculated value format if it\'s calculated value', () => {
                         aggregator = highchartsRenderer.rhPivotAggregatorMax(arg, widget_values_format, is_graph, render_options, calculated_info);
                         aggregatorObject = aggregator({}, ['Region average'], '');
                         expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
 
                     it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions and widget_value_format to equal first seriesOptions format', () => {
@@ -3047,6 +3633,7 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, ['Profit'], '');
                         aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
                         expect(aggregatorObject.format(1123.45678, false)).toBe('$1,123.457');
+                        expect(getAggregatorPercentageValueIfRequiredMock).toHaveBeenCalled();
                     });
                 });
             });
@@ -3054,6 +3641,115 @@ describe('highcharts_renderer', () => {
     });
 
     describe('function getDefaultValueForChart', () => {
+        let originalRich, originalGetter, originalSubDefaults;
+
+        beforeEach(() => {
+            originalRich = highchartsRenderer.richTextSubType;
+            originalGetter = highchartsRenderer.getChartOptionsBySubType;
+            originalSubDefaults = highchartsRenderer.getDefaultValueForSubOptions;
+
+            highchartsRenderer.richTextSubType = { type: 'rich_text', suboptions: [], default_options: null };
+        });
+
+        afterEach(() => {
+            highchartsRenderer.richTextSubType = originalRich;
+            highchartsRenderer.getChartOptionsBySubType = originalGetter;
+            highchartsRenderer.getDefaultValueForSubOptions = originalSubDefaults;
+        });
+
+        it('returns {} for unknown subtype', () => {
+            highchartsRenderer.getChartOptionsBySubType = jest.fn(() => null);
+            expect(highchartsRenderer.getDefaultValueForChart('unknown-type', {})).toEqual({});
+        });
+
+        it('deep-clones suboptions return value (no shared refs)', () => {
+            const shared = { arr: [1, 2, 3], nested: { x: 1 } };
+            highchartsRenderer.getDefaultValueForSubOptions = jest.fn(() => shared);
+
+            const chartOpt = {
+                suboptions: [{ category_type: 'segments' }, { category_type: 'label' }],
+                default_options: {},
+            };
+            highchartsRenderer.getChartOptionsBySubType = jest.fn(() => chartOpt);
+
+            const res = highchartsRenderer.getDefaultValueForChart('line-chart', {});
+            expect(res.segments).toEqual(shared);
+            expect(res.segments).not.toBe(shared);
+
+            res.segments.arr.push(99);
+            res.segments.nested.x = 42;
+            expect(shared.arr).toEqual([1, 2, 3]);
+            expect(shared.nested.x).toBe(1);
+        });
+
+        it('does not mutate chartOpt.default_options (base defaults stay immutable)', () => {
+            const baseDefaults = {
+                segments: [10, 20],
+                label: { font_size: 12, style: { weight: 400 } },
+            };
+            highchartsRenderer.getDefaultValueForSubOptions = jest.fn(() => ({ label: { font_size: 8 } }));
+            highchartsRenderer.getChartOptionsBySubType = jest.fn(() => ({
+                suboptions: [{ category_type: 'label' }],
+                default_options: baseDefaults,
+            }));
+
+            const res = highchartsRenderer.getDefaultValueForChart('line-chart', {});
+            res.label.style.weight = 700;
+            res.segments.push(30);
+
+            expect(baseDefaults).toEqual({
+                segments: [10, 20],
+                label: { font_size: 12, style: { weight: 400 } },
+            });
+        });
+
+        it('default_options override suboptions (old semantics) and arrays are replaced, not merged', () => {
+            highchartsRenderer.getDefaultValueForSubOptions = jest.fn((sub) => {
+                if (sub.category_type === 'segments') return [1, 2, 3];
+                if (sub.category_type === 'label') return { font_size: 8 };
+                return {};
+            });
+
+            highchartsRenderer.getChartOptionsBySubType = jest.fn(() => ({
+                suboptions: [{ category_type: 'segments' }, { category_type: 'label' }],
+                default_options: {
+                    segments: [100],
+                    label: { font_size: 12, color: '#000' },
+                },
+            }));
+
+            const res = highchartsRenderer.getDefaultValueForChart('line-chart', {});
+            expect(res.segments).toEqual([100]);                 // массив заменён целиком
+            expect(res.label).toEqual({ font_size: 12, color: '#000' }); // приоритет у default_options
+        });
+
+        it('fresh object on each call (no cross-call leakage)', () => {
+            highchartsRenderer.getDefaultValueForSubOptions = jest.fn(() => ({ a: 1 }));
+            highchartsRenderer.getChartOptionsBySubType = jest.fn(() => ({
+                suboptions: [{ category_type: 'cfg' }],
+                default_options: {},
+            }));
+
+            const res1 = highchartsRenderer.getDefaultValueForChart('line-chart', {});
+            const res2 = highchartsRenderer.getDefaultValueForChart('line-chart', {});
+            res1.cfg.a = 99;
+
+            expect(res2.cfg.a).toBe(1);
+            expect(res1.cfg).not.toBe(res2.cfg);
+        });
+
+        it('handles non-plain values inside defaults (e.g., Date) without throwing', () => {
+            const dt = new Date('2025-01-01T00:00:00.000Z');
+            highchartsRenderer.getDefaultValueForSubOptions = jest.fn(() => ({}));
+            highchartsRenderer.getChartOptionsBySubType = jest.fn(() => ({
+                suboptions: [],
+                default_options: { createdAt: dt },
+            }));
+
+            const res = highchartsRenderer.getDefaultValueForChart('line-chart', {});
+            expect(new Date(res.createdAt).getTime()).toBe(dt.getTime());
+        });
+
         it('should return empty value for rich_text type', () => {
             expect(highchartsRenderer.getDefaultValueForChart('rich_text', {})).toEqual({});
         });
@@ -6854,7 +7550,9 @@ describe('highcharts_renderer', () => {
             ]);
         });
         it('should prepare appropriate chart series for standard input', () => {
-            opts = {};
+            opts = {
+                chartOptions: {}
+            };
             chartType = null;
             const value = highchartsRenderer.ptCreateColumnSeries(pivotDataMock, colors, onlyNumbers, isUniqueVals, isNotDrillDown, additionalOptionsMock, opts, chartOptions, chartType);
             expect(value).toEqual([
@@ -7083,7 +7781,9 @@ describe('highcharts_renderer', () => {
                 "#b3060e",
                 "#70000a"
             ];
-            opts = {};
+            opts = {
+                chartOptions: {}
+            };
             chartOptions = {
                 chart: {
                     type: '',
@@ -7241,7 +7941,8 @@ describe('highcharts_renderer', () => {
 
         it('should prepare appropriate chart series, when opts \'total\' configuration is set to true', ()=> {
             opts = {
-                total: true
+                total: true,
+                chartOptions: {}
             };
             pivotDataMock.colTotals = {
                 'col 1': {value: () => 123450},
@@ -7310,6 +8011,7 @@ describe('highcharts_renderer', () => {
 
         it('should prepare appropriate chart series, when opts \'trendLine\' configuration is set to true', ()=> {
             opts = {
+                chartOptions: {},
                 trendLine: true
             };
             const value = highchartsRenderer.ptCreateBasicLineSeries(pivotDataMock, colors, onlyNumbers, isUniqueVals, additionalOptionsMock, opts, chartOptions);
@@ -7533,36 +8235,6 @@ describe('highcharts_renderer', () => {
             );
         });
 
-        it('should return no data result if series is empty', () => {
-            const chartOptions = {
-                chart: {},
-                series: [{ data: [] }, { data: [] }, {}],
-            };
-            const options = {};
-            const noDataFnSpy = jest.spyOn(highchartsRenderer, 'getNoDataResult').mockImplementation(() => {});
-
-            highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
-            
-            expect(noDataFnSpy).toHaveBeenCalled();
-            expect(options.error_has_occurred).toBeTruthy();
-            expect(options.error_params).toBe(highchartsRenderer.widgetPlaceholders.nodata);
-        });
-
-        it('should return too much data result if series is too long', () => {
-            const chartOptions = {
-                chart: {},
-                series: [{ data: new Array(1000) }, { data: new Array(1000) }, {}],
-            };
-            const options = {};
-            const noDataFnSpy = jest.spyOn(highchartsRenderer, 'getNoDataResult').mockImplementation(() => {});
-
-            highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
-
-            expect(noDataFnSpy).toHaveBeenCalled();
-            expect(options.error_has_occurred).toBeTruthy();
-            expect(options.error_params).toBe(highchartsRenderer.widgetPlaceholders.tooMuchData);
-        });
-
         it('should set hcInstance on options with chart object for graph table renderer to use', () => {
             jest.useFakeTimers();
             jest.spyOn(Highcharts, 'chart').mockImplementation(() => ({ chart: true }));
@@ -7580,40 +8252,330 @@ describe('highcharts_renderer', () => {
         });
     });
 
-    describe('Function getNoDataResult', () => {
-        const container = $('<div class="noData-box"></div>');
+    describe('Error Throwing Functionality', () => {
+        const {
+            NoDataError,
+            TooMuchDataError,
+            DataConflictError,
+            GaugeConfigurationError,
+            BaseRendererError,
+            GenericRenderingError,
+            GenericComputationalError
+        } = require('../src/errors');
 
-        it('should return no data html', () => {
-            const placeholderMeta = highchartsRenderer.widgetPlaceholders.nodata;
-            const expected = container.clone().html(highchartsRenderer.getWidgetPlaceholder(placeholderMeta));
-            expect(highchartsRenderer.getNoDataResult()).toEqual(expected);
+        beforeEach(() => {
+            jest.clearAllMocks();
         });
 
-        it('should return too much data html', () => {
-            const placeholderMeta = highchartsRenderer.widgetPlaceholders.tooMuchData;
-            const expected = container.clone().html(highchartsRenderer.getWidgetPlaceholder(placeholderMeta));
-            expect(highchartsRenderer.getNoDataResult(true)).toEqual(expected);
+        afterAll(() => {
+            jest.restoreAllMocks();
         });
 
-    });
+        describe('ptCreateElementAndDraw - Error Throwing', () => {
+            it('should throw NoDataError when series is empty and not onlyText', () => {
+                const chartOptions = {
+                    chart: {},
+                    series: [{ data: [] }, { data: [] }, {}],
+                };
+                const options = {};
+
+                expect(() => {
+                    highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
+                }).toThrow(NoDataError);
+            });
+
+            it('should throw TooMuchDataError when series has too much data', () => {
+                const chartOptions = {
+                    chart: {},
+                    series: [{ data: new Array(1000) }, { data: new Array(1000) }, {}],
+                };
+                const options = {};
+
+                expect(() => {
+                    highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
+                }).toThrow(TooMuchDataError);
+            });
+
+            it('should not throw errors when onlyText is true even if no data', () => {
+                const chartOptions = {
+                    chart: {},
+                    series: [{ data: [] }],
+                    onlyText: true,
+                };
+                const options = {};
+
+                expect(() => {
+                    highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
+                }).not.toThrow();
+            });
+
+            it('should process normally when series has valid data', () => {
+                jest.spyOn(Highcharts, 'chart').mockImplementation(() => ({ chart: true }));
+                jest.useFakeTimers();
+
+                const chartOptions = {
+                    chart: {},
+                    series: [{ data: [1, 2, 3] }],
+                };
+                const options = {};
 
-    describe('Function getWidgetPlaceholder', () => {
-        const titleSelector = '.noData-title';
-        const imageSelector = '.noData-image';
-        const textSelector = '.noData-text';
+                expect(() => {
+                    highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
+                }).not.toThrow();
+
+                jest.runAllTimers();
+                jest.restoreAllMocks();
+                jest.useRealTimers();
+            });
+        });
+
+        describe('Data Conflict Error Throwing', () => {
+            it('should throw DataConflictError when categories are below minimum in waterfall chart', () => {
+                const options = {
+                    isBreakdown: true,
+                    uniqueCategories: ['A', 'B'], // Only 2 categories
+                    minCategories: 5,
+                    maxCategories: 10
+                };
+
+                expect(() => {
+                    throw new DataConflictError({
+                        isBreakdown: options.isBreakdown,
+                        uniqueCategories: options.uniqueCategories,
+                        minCategories: options.minCategories,
+                        maxCategories: options.maxCategories
+                    });
+                }).toThrow(DataConflictError);
+            });
+
+            it('should throw DataConflictError when categories exceed maximum in waterfall chart', () => {
+                const uniqueCategories = new Array(15).fill(0).map((_, i) => `Category${i}`); // 15 categories
+                const options = {
+                    isBreakdown: false,
+                    uniqueCategories,
+                    minCategories: 3,
+                    maxCategories: 10
+                };
+
+                expect(() => {
+                    throw new DataConflictError({
+                        isBreakdown: options.isBreakdown,
+                        uniqueCategories: options.uniqueCategories,
+                        minCategories: options.minCategories,
+                        maxCategories: options.maxCategories
+                    });
+                }).toThrow(DataConflictError);
+            });
+
+            it('should create DataConflictError with correct options for breakdown scenario', () => {
+                const options = {
+                    isBreakdown: true,
+                    uniqueCategories: ['A'],
+                    minCategories: 5,
+                    maxCategories: 10
+                };
+
+                try {
+                    throw new DataConflictError(options);
+                } catch (error) {
+                    expect(error).toBeInstanceOf(DataConflictError);
+                    expect(error.code).toBe(5);
+                    expect(error.title).toBe('Data Conflict');
+                    expect(error.options).toEqual(options);
+                    expect(error.options.isBreakdown).toBe(true);
+                    expect(error.options.uniqueCategories).toEqual(['A']);
+                    expect(error.options.minCategories).toBe(5);
+                    expect(error.options.maxCategories).toBe(10);
+                }
+            });
+
+            it('should create DataConflictError with correct options for walkthrough scenario', () => {
+                const options = {
+                    isBreakdown: false,
+                    uniqueCategories: ['A', 'B', 'C'],
+                    minCategories: 5,
+                    maxCategories: 8
+                };
+
+                try {
+                    throw new DataConflictError(options);
+                } catch (error) {
+                    expect(error).toBeInstanceOf(DataConflictError);
+                    expect(error.code).toBe(5);
+                    expect(error.title).toBe('Data Conflict');
+                    expect(error.options).toEqual(options);
+                    expect(error.options.isBreakdown).toBe(false);
+                }
+            });
+        });
+
+        describe('Gauge Configuration Error Throwing', () => {
+            it('should create GaugeConfigurationError with correct properties', () => {
+                try {
+                    throw new GaugeConfigurationError();
+                } catch (error) {
+                    expect(error).toBeInstanceOf(GaugeConfigurationError);
+                    expect(error.code).toBe(6);
+                    expect(error.title).toBe('Please configure goal and needle');
+                    expect(error.options).toEqual({});
+                }
+            });
 
-        it('should return default placeholder when no data is provided', () => {
-            const placeholder = highchartsRenderer.getWidgetPlaceholder();
-            const defaultPlaceholder = '<div class="noData"><i class="noData-image"></i> no data</div>';
-            expect(placeholder[0].outerHTML).toEqual(defaultPlaceholder);
+            it('should be instance of BaseRendererError', () => {
+                const error = new GaugeConfigurationError();
+                expect(error).toBeInstanceOf(require('../src/errors').BaseRendererError);
+            });
         });
 
-        it('should return placeholder html when data is provided', () => {
-            Object.entries(highchartsRenderer.widgetPlaceholders).forEach(([, value]) => {
-                const placeholder = highchartsRenderer.getWidgetPlaceholder(value)[0];
-                expect(placeholder.querySelector(titleSelector).innerHTML).toEqual(value.title);
-                expect(placeholder.querySelector(imageSelector).classList.contains(value.class)).toBeTruthy();
-                expect(placeholder.querySelector(textSelector).innerHTML).toEqual(value.text);
+        describe('Error handling in rhPivotView functions (testing private _handleComputationalError and _handleRenderingError)', () => {
+            beforeEach(() => {
+                jest.spyOn(console, 'error').mockImplementation(() => {});
+            });
+
+            afterEach(() => {
+                jest.restoreAllMocks();
+            });
+
+            describe('Natural error conditions (testing private error handlers indirectly)', () => {
+                it('should handle too much data error correctly', () => {
+                    // Create dataset that exceeds MAX_ROWS_FOR_SHOW_RESULTS to trigger TooMuchDataError
+                    const largeRowData = new Array(highchartsRenderer.MAX_ROWS_FOR_SHOW_RESULTS + 1)
+                        .fill({ field1: 'value1', field2: 'value2' });
+                    
+                    const options = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn()
+                    };
+
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(largeRowData, options);
+                    }).toThrow(TooMuchDataError);
+                });
+
+                it('should return empty object for too much data when onlyOptions is true', () => {
+                    // Create dataset that exceeds MAX_ROWS_FOR_SHOW_RESULTS
+                    const largeRowData = new Array(highchartsRenderer.MAX_ROWS_FOR_SHOW_RESULTS + 1)
+                        .fill({ field1: 'value1', field2: 'value2' });
+                    
+                    const options = {
+                        onlyOptions: true,
+                        rendererOptions: {},
+                        renderer: jest.fn()
+                    };
+
+                    const result = highchartsRenderer.rhPivotView(largeRowData, options);
+                    expect(result).toEqual({});
+                });
+
+                it('should handle no data error correctly', () => {
+                    const options = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn()
+                    };
+
+                    // Empty rowData should trigger NoDataError
+                    expect(() => {
+                        highchartsRenderer.rhPivotView([], options);
+                    }).toThrow(NoDataError);
+                });
+
+                it('should return empty object for no data when onlyOptions is true', () => {
+                    const options = {
+                        onlyOptions: true,
+                        rendererOptions: {},
+                        renderer: jest.fn()
+                    };
+
+                    const result = highchartsRenderer.rhPivotView([], options);
+                    expect(result).toEqual({});
+                });
+
+                it('should handle renderer errors correctly', () => {
+                    const rowData = [{ field1: 'value1', field2: 'value2' }];
+                    const genericError = new Error('Renderer failed');
+                    
+                    const options = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn().mockImplementation(() => {
+                            throw genericError;
+                        })
+                    };
+
+                    // Generic errors from renderer should be wrapped in GenericRenderingError
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(rowData, options);
+                    }).toThrow(GenericRenderingError);
+                });
+
+                it('should return empty object for renderer errors when onlyOptions is true', () => {
+                    const rowData = [{ field1: 'value1', field2: 'value2' }];
+                    const genericError = new Error('Renderer failed');
+                    
+                    const options = {
+                        onlyOptions: true,
+                        rendererOptions: {},
+                        renderer: jest.fn().mockImplementation(() => {
+                            throw genericError;
+                        })
+                    };
+
+                    const result = highchartsRenderer.rhPivotView(rowData, options);
+                    expect(result).toEqual({});
+                });
+
+                it('should re-throw BaseRendererError instances from renderer unchanged', () => {
+                    const rowData = [{ field1: 'value1', field2: 'value2' }];
+                    const originalError = new NoDataError();
+                    
+                    const options = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn().mockImplementation(() => {
+                            throw originalError;
+                        })
+                    };
+
+                    // BaseRendererError instances should be re-thrown unchanged
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(rowData, options);
+                    }).toThrow(NoDataError);
+                    
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(rowData, options);
+                    }).toThrow(originalError);
+                });
+
+                it('should handle null/undefined from renderer as GenericRenderingError', () => {
+                    const rowData = [{ field1: 'value1', field2: 'value2' }];
+                    
+                    // Test null
+                    const nullOptions = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn().mockImplementation(() => {
+                            throw null;
+                        })
+                    };
+
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(rowData, nullOptions);
+                    }).toThrow(GenericRenderingError);
+
+                    const undefinedOptions = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn().mockImplementation(() => {
+                            throw undefined;
+                        })
+                    };
+
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(rowData, undefinedOptions);
+                    }).toThrow(GenericRenderingError);
+                });
             });
         });
     });