@datarailsshared/dr_renderer 1.3.59 → 1.4.6

package/tests/mock/widgets.json

@@ -314,7 +314,6 @@
         },
         "seriesOptions": []
       },
-      "error_params": null,
       "chart_title": "New Widget234",
       "chartLabels": {
         "legend": "Data series",
@@ -371,8 +370,7 @@
           "is_end_of_period": true,
           "is_formatting_by_aggregation_method": true
         }
-      ],
-      "error_has_occurred": false
+      ]
     },
     "vals": [
       {

package/tests/ptCreateDrillDownSeriesToDrilldownChart.test.js

@@ -0,0 +1,511 @@
+import * as JQuery from "jquery";
+import * as lodash from 'lodash';
+import moment from 'moment/min/moment.min';
+import initPivotTable from "../src/pivottable";
+import initDRPivotTable from "../src/dr_pivottable";
+
+const getHighchartsRenderer = require('../src/highcharts_renderer');
+const DataFormatter = require('../src/dataformatter');
+
+global.$ = JQuery;
+global.lodash = lodash;
+
+const Highcharts = {
+    Color: jest.fn(),
+    chart: jest.fn(),
+    setOptions: jest.fn(),
+    wrap: jest.fn(),
+    Tooltip: {
+        prototype: {
+            hide: jest.fn()
+        }
+    },
+    Point: {
+        prototype: {
+            setState: jest.fn()
+        }
+    },
+    Series: {
+        prototype: {
+            setState: jest.fn()
+        }
+    },
+    defaultOptions: {
+        global: {
+            useUTC: false
+        }
+    },
+    merge: jest.fn((target, source) => Object.assign({}, target, source))
+};
+
+const _document = {
+    createElement: jest.fn(() => ({
+        style: {},
+        setAttribute: jest.fn(),
+        appendChild: jest.fn()
+    })),
+    body: {
+        appendChild: jest.fn()
+    }
+};
+
+function createMockAggregator(value) {
+    return {
+        value: () => value
+    };
+}
+
+
+let highchartsRenderer = {};
+
+describe('ptCreateDrillDownSeriesToDrilldownChart', () => {
+    let mockPivotData;
+    let mockChartOptions;
+    let mockAdditionOptions;
+    let mockOpts;
+
+    beforeAll(() => {
+        const _window = {
+            DataFormatter: DataFormatter
+        };
+        
+        initPivotTable(JQuery, _window, _document);
+        initDRPivotTable(JQuery, _window, _document);
+        
+        const DEFAULT_USER_COLORS = ['#7cb5ec', '#434348', '#90ed7d', '#f7a35c', '#8085e9', '#f15c80', '#e4d354', '#2b908f', '#f45b5b', '#91e8e1'];
+        highchartsRenderer = getHighchartsRenderer(JQuery, _document, Highcharts, lodash.cloneDeep(DEFAULT_USER_COLORS), highchartsRenderer, DataFormatter, lodash, moment, false);
+    });
+
+    beforeEach(() => {
+        const createMockAggregator = (value) => ({
+            value: () => value
+        });
+
+        mockPivotData = {
+            getRowKeys: jest.fn(() => [
+                ['CITY SERVICE DEPTS'],
+                ['MID-SOUTH'],
+                ['NORTH TX'],
+                ['SOUTH TX'],
+                ['VIRGINIA'],
+                ['CAROLINA']
+            ]),
+            getColKeys: jest.fn(() => [
+                ['003-NATIONAL ACCOUNTS'],
+                ['015-MEMPHIS'],
+                ['016-WICHITA FALLS'],
+                ['017-AMARILLO'],
+                ['019-AUSTIN'],
+                ['020-NORFOLK'],
+                ['023-NEWPORT NEWS'],
+                ['035-CHARLOTTE CITY SERVICE']
+            ]),
+            getAggregator: jest.fn((rowKey, colKey) => {
+                const rowStr = Array.isArray(rowKey) ? rowKey[0] : rowKey;
+                const colStr = Array.isArray(colKey) ? colKey[0] : colKey;
+                
+                const dataMap = {
+                    'CITY SERVICE DEPTS,003-NATIONAL ACCOUNTS': 305550.96,
+                    'MID-SOUTH,015-MEMPHIS': 78827.94,
+                    'NORTH TX,016-WICHITA FALLS': 28926.52,
+                    'NORTH TX,017-AMARILLO': 92653.77,
+                    'SOUTH TX,019-AUSTIN': 103645.51,
+                    'VIRGINIA,020-NORFOLK': 0,
+                    'VIRGINIA,023-NEWPORT NEWS': 19997.5,
+                    'CAROLINA,035-CHARLOTTE CITY SERVICE': 124248.97
+                };
+                
+                const key = `${rowStr},${colStr}`;
+                const value = dataMap[key] || null;
+                
+                return createMockAggregator(value);
+            }),
+            colFormats: [
+                {
+                    type: "Text",
+                    name: "Br number & Name",
+                    format: null,
+                    val_not_convert: []
+                }
+            ],
+            rowFormats: [
+                {
+                    type: "Text",
+                    name: "Area",
+                    format: null,
+                    val_not_convert: []
+                }
+            ]
+        };
+
+        mockChartOptions = {
+            chart: {
+                type: 'pie'
+            }
+        };
+
+        mockAdditionOptions = {
+            dataLabels: {
+                color: '#151a41'
+            }
+        };
+
+        mockOpts = {
+            total_value_options: {
+                filter_options: {
+                    filteredOutFieldName: 'Others'
+                }
+            }
+        };
+
+        jest.spyOn(highchartsRenderer, 'getFormattedColKey').mockImplementation((name) => name);
+        jest.spyOn(highchartsRenderer, 'getFormattedRowKey').mockImplementation((name) => Array.isArray(name) ? name : [name]);
+        jest.spyOn(highchartsRenderer, 'moveSeriesToSecondYAxisIfNeeded').mockImplementation(() => {});
+        jest.spyOn(highchartsRenderer, 'getDataLabelsStylesForDrillDown').mockReturnValue({
+            activeDataLabelStyle: {
+                color: '#151a41'
+            }
+        });
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe('with valid pivot data', () => {
+        it('should create drill-down series correctly', () => {
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            // Verify the structure of the result
+            expect(result).toHaveProperty('activeDataLabelStyle');
+            expect(result).toHaveProperty('series');
+            expect(result.activeDataLabelStyle).toEqual({
+                color: '#151a41'
+            });
+
+            // Verify series structure
+            expect(Array.isArray(result.series)).toBe(true);
+            expect(result.series.length).toBe(7);
+
+            // Check first series (003-NATIONAL ACCOUNTS)
+            const firstSeries = result.series[0];
+            expect(firstSeries).toMatchObject({
+                id: '003-NATIONAL ACCOUNTS',
+                initialName: '003-NATIONAL ACCOUNTS',
+                name: '003-NATIONAL ACCOUNTS',
+                data: expect.any(Array)
+            });
+
+            // Verify data points in first series
+            expect(firstSeries.data).toHaveLength(1);
+            expect(firstSeries.data[0]).toMatchObject({
+                name: ['CITY SERVICE DEPTS'],
+                initialName: ['CITY SERVICE DEPTS'],
+                y: 305550.96
+            });
+        });
+
+        it('should handle numeric column IDs correctly', () => {
+            // Test with numeric column keys
+            mockPivotData.getColKeys.mockReturnValue([
+                [123],
+                [456]
+            ]);
+
+            mockPivotData.getAggregator.mockImplementation(() => createMockAggregator(100));
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            expect(result.series[0].id).toBe(123);
+            expect(result.series[1].id).toBe(456);
+        });
+
+        it('should handle boolean column IDs correctly', () => {
+            // Test with boolean column keys
+            mockPivotData.getColKeys.mockReturnValue([
+                [true],
+                [false]
+            ]);
+
+            mockPivotData.getAggregator.mockImplementation(() => createMockAggregator(100));
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            expect(result.series[0].id).toBe('true');
+            expect(result.series[1].id).toBe('false');
+        });
+
+        it('should filter out null values', () => {
+            mockPivotData.getAggregator.mockImplementation((rowKey, colKey) => {
+                const rowStr = Array.isArray(rowKey) ? rowKey[0] : rowKey;
+                const colStr = Array.isArray(colKey) ? colKey[0] : colKey;
+                
+                // Return null for specific combinations
+                if (rowStr === 'CITY SERVICE DEPTS' && colStr === '015-MEMPHIS') {
+                    return { value: () => null };
+                }
+                
+                return { value: () => 100 };
+            });
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            // Find the series for '015-MEMPHIS'
+            const memphisSeries = result.series.find(s => s.id === '015-MEMPHIS');
+            
+            // Should not include data point with null value
+            expect(memphisSeries.data).not.toContainEqual(
+                expect.objectContaining({
+                    name: ['CITY SERVICE DEPTS']
+                })
+            );
+        });
+
+        it('should handle undefined column keys', () => {
+            mockPivotData.getColKeys.mockReturnValue([
+                [undefined],
+                ['valid-key']
+            ]);
+            
+            mockPivotData.getAggregator.mockImplementation((rowKey, colKey) => {
+                return { value: () => 100 }; // Return valid value for all combinations
+            });
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            // Should only process series with defined column keys (undefined keys are filtered out)
+            expect(result.series).toHaveLength(1);
+            expect(result.series[0].id).toBe('valid-key');
+        });
+
+        it('should handle empty row keys', () => {
+            mockPivotData.getRowKeys.mockReturnValue([
+                [null],
+                [''],
+                ['valid-row']
+            ]);
+
+            mockPivotData.getAggregator.mockImplementation((rowKey) => {
+                const rowStr = Array.isArray(rowKey) ? rowKey[0] : rowKey;
+                if (!rowStr) {
+                    return { value: () => 100 };
+                }
+                return { value: () => 200 };
+            });
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            // Should filter out data points with null/empty row keys
+            result.series.forEach(series => {
+                series.data.forEach(dataPoint => {
+                    expect(dataPoint.name[0]).toBeTruthy();
+                });
+            });
+        });
+
+        it('should convert string numbers to float', () => {
+            mockPivotData.getAggregator.mockImplementation(() => ({
+                value: () => '123.45' // Return string number
+            }));
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            result.series.forEach(series => {
+                series.data.forEach(dataPoint => {
+                    expect(typeof dataPoint.y).toBe('number');
+                    expect(dataPoint.y).toBe(123.45);
+                });
+            });
+        });
+
+        it('should remove duplicate data points', () => {
+            // Mock duplicate row keys
+            mockPivotData.getRowKeys.mockReturnValue([
+                ['DUPLICATE'],
+                ['DUPLICATE'],
+                ['UNIQUE']
+            ]);
+
+            mockPivotData.getAggregator.mockImplementation(() => ({
+                value: () => 100
+            }));
+
+            // Mock getFormattedRowKey to return same name for duplicates
+            jest.spyOn(highchartsRenderer, 'getFormattedRowKey').mockImplementation((name) => {
+                if (Array.isArray(name) && name[0] === 'DUPLICATE') {
+                    return ['DUPLICATE'];
+                }
+                return Array.isArray(name) ? name : [name];
+            });
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            // Each series should have unique data points
+            result.series.forEach(series => {
+                const names = series.data.map(d => d.name.join(','));
+                const uniqueNames = [...new Set(names)];
+                expect(names.length).toBe(uniqueNames.length);
+            });
+        });
+
+        it('should call helper functions with correct parameters', () => {
+            highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            expect(highchartsRenderer.moveSeriesToSecondYAxisIfNeeded).toHaveBeenCalledWith(
+                expect.any(Array),
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+            expect(highchartsRenderer.getDataLabelsStylesForDrillDown).toHaveBeenCalledWith(mockAdditionOptions);
+        });
+
+        it('should merge values when row name is a plain string (not array)', () => {
+            jest.spyOn(highchartsRenderer, 'getFormattedRowKey').mockImplementation(name => name);
+
+            mockPivotData.getRowKeys.mockReturnValue([ 'PLAIN_STRING_NAME' ]);
+            mockPivotData.getColKeys.mockReturnValue([ ['valid-key'] ]);
+            mockPivotData.getAggregator.mockImplementation(() => ({ value: () => 100 }));
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            expect(result.series).toHaveLength(1);
+            const dataPoint = result.series[0].data[0];
+            expect(dataPoint.name).toEqual(['PLAIN_STRING_NAME']);
+            expect(dataPoint.y).toBe(100);
+        });
+    });
+
+    describe('edge cases', () => {
+        it('should handle empty column keys', () => {
+            mockPivotData.getColKeys.mockReturnValue([]);
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            expect(result.series).toHaveLength(0);
+        });
+
+        it('should handle empty row keys', () => {
+            mockPivotData.getRowKeys.mockReturnValue([]);
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            // Series should exist but have no data
+            result.series.forEach(series => {
+                expect(series.data).toHaveLength(0);
+            });
+        });
+
+        it('should filter out series with no data', () => {
+            // Mock aggregator to return null for all combinations
+            mockPivotData.getAggregator.mockImplementation(() => ({
+                value: () => null
+            }));
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            expect(result.series).toHaveLength(0);
+        });
+    });
+
+    describe('with Others key handling', () => {
+        it('should replace DR_OTHERS_KEY with othersName', () => {
+            // Mock DR_OTHERS_KEY constant
+            highchartsRenderer.DR_OTHERS_KEY = 'DR_OTHERS_KEY';
+            
+            mockPivotData.getColKeys.mockReturnValue([
+                ['DR_OTHERS_KEY'],
+                ['normal-key']
+            ]);
+
+            mockPivotData.getRowKeys.mockReturnValue([
+                ['DR_OTHERS_KEY'],
+                ['normal-row']
+            ]);
+            
+            // Mock aggregator to return valid data
+            mockPivotData.getAggregator.mockImplementation((rowKey, colKey) => {
+                return { value: () => 100 }; // Return valid value for all combinations
+            });
+
+            const result = highchartsRenderer.ptCreateDrillDownSeriesToDrilldownChart(
+                mockPivotData,
+                mockChartOptions,
+                mockAdditionOptions,
+                mockOpts
+            );
+
+            // Check that DR_OTHERS_KEY is replaced with Others name
+            const othersColSeries = result.series.find(s => s.initialName === 'Others');
+            expect(othersColSeries).toBeDefined();
+            expect(othersColSeries.name).toBe('Others');
+        });
+    });
+});
+

package/tests/value.formatter.test.js

@@ -0,0 +1,143 @@
+const { getAggregatorPercentageValueIfRequired, getRelatedValue, isAbsoluteValue } = require('../src/value.formatter');
+
+describe('Function getAggregatorPercentageValueIfRequired', () => {
+    let render_options, rowKey, colKey;
+
+    beforeEach(() => {
+        render_options = {
+            comboOptions: { secondaryAxisSettings: { is_percentage: true } },
+            chartOptions: { 
+                delta_column: { 
+                    name: 'Variance',
+                    formula: 'x2-x1',
+                    is_percentage: false
+                } 
+            }
+        };
+        rowKey = ['Variance'];
+        colKey = ['SomeCol'];
+    });
+
+    it('should return percentage string when secondaryAxisSettings.is_percentage is true but delta_column.is_percentage is false', () => {
+        const data = {
+            rowKeys: ['Variance'],
+            getAggregator: jest.fn(() => ({
+                value: () => 200
+            }))
+        };
+        const result = getAggregatorPercentageValueIfRequired(50, render_options, data, rowKey, colKey);
+        expect(result).toBe('25%');
+    });
+
+    it('should return percentage string when secondaryAxisSettings.is_percentage is false but delta_column.is_percentage is true', () => {
+        const data = {
+            rowKeys: ['Variance'],
+            getAggregator: jest.fn(() => ({
+                value: () => 200
+            }))
+        };
+        render_options.comboOptions.secondaryAxisSettings.is_percentage = false;
+        render_options.chartOptions.delta_column.is_percentage = true;
+        const result = getAggregatorPercentageValueIfRequired(50, render_options, data, rowKey, colKey);
+        expect(result).toBe('25%');
+    });
+
+    it('should return null if is_percentage is false', () => {
+        const data = {
+            rowKeys: ['Variance'],
+            getAggregator: jest.fn()
+        };
+        render_options.comboOptions.secondaryAxisSettings.is_percentage = false;
+        const result = getAggregatorPercentageValueIfRequired(50, render_options, data, rowKey, colKey);
+        expect(result).toBeNull();
+    });
+
+    it('should return null if isVariance is false', () => {
+        const data = {
+            rowKeys: ['NotVariance'],
+            getAggregator: jest.fn()
+        };
+        rowKey = ['NotVariance'];
+        const result = getAggregatorPercentageValueIfRequired(50, render_options, data, rowKey, colKey);
+        expect(result).toBeNull();
+    });
+
+    it('should return null if baseRowKey is missing', () => {
+        const data = {
+            rowKeys: [],
+            getAggregator: jest.fn()
+        };
+        const result = getAggregatorPercentageValueIfRequired(50, render_options, data, rowKey, colKey);
+        expect(result).toBeNull();
+    });
+
+    it('should return null if agg is missing', () => {
+        const data = {
+            rowKeys: ['Variance'],
+            getAggregator: jest.fn(() => null)
+        };
+        const result = getAggregatorPercentageValueIfRequired(50, render_options, data, rowKey, colKey);
+        expect(result).toBeNull();
+    });
+
+    it('should return null if data is null', () => {
+        const result = getAggregatorPercentageValueIfRequired(50, render_options, null, rowKey, colKey);
+        expect(result).toBeNull();
+    });
+
+    it('should return null if data is undefined', () => {
+        const result = getAggregatorPercentageValueIfRequired(50, render_options, undefined, rowKey, colKey);
+        expect(result).toBeNull();
+    });
+
+    it('should return null if baseRowKey is null even when data exists', () => {
+        const data = {
+            rowKeys: [null],
+            getAggregator: jest.fn()
+        };
+        const result = getAggregatorPercentageValueIfRequired(50, render_options, data, rowKey, colKey);
+        expect(result).toBeNull();
+        expect(data.getAggregator).not.toHaveBeenCalled();
+    });
+});
+
+describe('Function getRelatedValue', () => {
+    it('should return -1 when baseValue is falsy and value < 0', () => {
+        expect(getRelatedValue(-50, 0)).toBe(-1);
+    });
+
+    it('should return 1 when baseValue is falsy and value >= 0', () => {
+        expect(getRelatedValue(50, null)).toBe(1);
+    });
+
+    it('should return related value when baseValue is truthy', () => {
+        expect(getRelatedValue(50, 200)).toBe(0.25);
+        expect(getRelatedValue(200, 200)).toBe(1);
+    });
+});
+
+describe('Function isAbsoluteValue', () => {
+    it('should return false if formula is undefined', () => {
+        expect(isAbsoluteValue(undefined)).toBe(false);
+    });
+
+    it('should return false if formula is null', () => {
+        expect(isAbsoluteValue(null)).toBe(false);
+    });
+
+    it('should return false if formula contains "/"', () => {
+        expect(isAbsoluteValue('/')).toBe(false);
+        expect(isAbsoluteValue(' / ')).toBe(false);
+    });
+
+    it('should return true if formula does not contain "/"', () => {
+        expect(isAbsoluteValue('x2-x1')).toBe(true);
+        expect(isAbsoluteValue(' x1 - x2 ')).toBe(true);
+        expect(isAbsoluteValue('some text x2-x1 more text')).toBe(true);
+    });
+
+    it('should ignore spaces in formula', () => {
+        expect(isAbsoluteValue('x2 - x1')).toBe(true);
+        expect(isAbsoluteValue('  x1   -   x2  ')).toBe(true);
+    });
+});

package/tsconfig.json

@@ -2,7 +2,7 @@
     "compilerOptions": {
         "declaration": true,
         "allowJs": true,
-        "declarationDir": "./types",
+        "declarationDir": "./src/types",
         "checkJs": true,
         "moduleResolution": "Node16",
         "module": "Node16",
@@ -10,6 +10,6 @@
         "emitDeclarationOnly": true,
         "strict": true
     },
-    "include": ["./src/graph-table-renderer.js"],
+    "include": ["./src/graph-table-renderer.js", "./src/errors.js"],
     "exclude": ["node_modules"]
 }

package/tsconfig.tsbuildinfo

@@ -0,0 +1,7 @@
+{
+    "root": [
+        "./src/graph-table-renderer.js",
+        "./src/errors.js"
+    ],
+    "version": "5.9.2"
+}