@datarailsshared/dr_renderer 1.4.61 → 1.4.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datarailsshared/dr_renderer",
-  "version": "1.4.61",
+  "version": "1.4.67",
   "description": "DataRails charts and tables renderer",
   "keywords": [
     "datarails",

package/src/highcharts_renderer.js

@@ -670,7 +670,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 }
 
                 var cols = highchartsRenderer.getColsInFormatterContext(this);
-                if (typeof (cols) == 'object' && cols.name) {
+                if (typeof (cols) == 'object' && cols && cols.name) {
                     cols = cols.name;
                 }
 
@@ -5256,10 +5256,27 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         }
     };
 
-    highchartsRenderer.setMissingWidgetOptions = function(options, type) {
-        if (!lodash.has(options, 'chartOptions')) return;
+    highchartsRenderer.setMissingWidgetOptions = function (options, type) {
+        if (!options || !lodash.has(options, 'chartOptions')) return;
+
         const defaultOptions = highchartsRenderer.getDefaultValueForChart(type);
-        options.chartOptions = lodash.merge(defaultOptions, options.chartOptions);
+
+        // User can remove segment and this part of code was made to
+        // prevent a set of default value
+        if (type === highchartsRenderer.CHART_TYPES.GAUGE_CHART_DYNAMIC_GOAL) {
+            const chartOptions = options.chartOptions || {};
+            const userSegments = chartOptions.segments;
+            const merged = lodash.merge({}, defaultOptions, lodash.omit(chartOptions, 'segments'));
+
+            if (Array.isArray(userSegments)) {
+                merged.segments = userSegments;
+            }
+
+            options.chartOptions = merged;
+            return;
+        }
+
+        options.chartOptions = lodash.merge({}, defaultOptions, options.chartOptions);
     };
 
     highchartsRenderer.addPivotOptions = function (selectedTemplateWOData, widgetOptions, drilldownFunction, drillDownListFunction) {

package/tests/highcharts_renderer.test.js

@@ -511,19 +511,559 @@ 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'],
+                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);
+
+            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 "', () => {
+                highchartsRenderer.selfStartsWith.and.returnValue(true);
+                highchartsRenderer.getSeriesNameInFormatterContext.and.returnValue('Series 1');
+
+                opts = { chartOptions: {} };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts, true);
+                let result = fn.call(funcContext);
+
+                expect(highchartsRenderer.selfStartsWith).toHaveBeenCalledWith('Series 1', 'Series ');
+                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');
+            });
         });
     });
 
@@ -7657,7 +8197,7 @@ describe('highcharts_renderer', () => {
             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);