@datarailsshared/dr_renderer 1.2.317-rocket → 1.2.318-rocket

package/package.json

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

package/src/dr_pivottable.js

@@ -91,7 +91,6 @@ let initDRPivotTable = function($, window, document) {
 
         DRPivotData.prototype.arrSort = function(attrs) {
             var a, sortersArr;
-            const sortByValueAttrs = this.sortByValueAttrs;
             sortersArr = (function() {
                 var l, len1, results;
                 results = [];
@@ -101,21 +100,11 @@ let initDRPivotTable = function($, window, document) {
                 }
                 return results;
             }).call(this);
-
             return function(a, b) {
                 var comparison, i, sorter;
                 for (i in sortersArr) {
-                    const index = parseInt(i);
-                    sorter = sortersArr[index];
-                    if (sortByValueAttrs.indexOf(attrs[index]) !== -1) {
-
-                        // For case current Field attrs[index] is sorted by value we are concatenating values passed to sorter function
-                        // Concatenation is done from first field in a block (first axis or first series) until current field index.
-                        // Cause for this case sorting will be as list of these concatenated strings (which is prepared in getSortingByValueOrderList)
-                        comparison = sorter(a.slice(0, index + 1).join(','), b.slice(0, index + 1).join(','));
-                    } else {
-                        comparison = sorter(a[index], b[index]);
-                    }
+                    sorter = sortersArr[i];
+                    comparison = sorter(a[i], b[i]);
                     if (comparison !== 0) {
                         return comparison;
                     }

package/src/highcharts_renderer.js

@@ -1460,7 +1460,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 totalSeries.color = colors[i];
             }
 
-        if (!lodash.isEmpty(pivotData.colTotals)) {
             col_n_keys.forEach(columnKey => {
                 let key = columnKey;
                 let totalKey = columnKey;
@@ -1471,18 +1470,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 const value = pivotData.colTotals[totalKey] ? pivotData.colTotals[totalKey].value() : 0;
                 totalSeries.data.push({name: lodash.unescape(key), y: value});
             });
-        } else {
-            lodash.forEach(row_n_keys, (rowKey, index) => {
-                let key = rowKey;
-                let totalKey = rowKey;
-                if (lodash.isArray(rowKey)) {
-                    key = col_n_keys[index];
-                    totalKey = totalKey.join(highchartsRenderer.delimer);
-                }
-                const value = pivotData.rowTotals[totalKey] ? pivotData.rowTotals[totalKey].value() : 0;
-                totalSeries.data.push({name: lodash.unescape(key), y: value});
-            });
-        }
 
             chart_series.push(totalSeries);
         }
@@ -4421,42 +4408,72 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         return ret_str;
     };
 
-    highchartsRenderer.getSortingByValueOrderList = function (pivotData, sortingOptions, keysArray, attrs, fieldIndex, widget) {
-        let values_names_arr = [];
-        lodash.forEach(keysArray, function (val) {
-            const firstArray = [];
-            const secondArray = val.slice(0, fieldIndex + 1);
-
-            let valueForComparison;
-            if (sortingOptions.sort_by === 'variance') {
-                const varianceConfig = widget.options.chartOptions.delta_column;
-                const data = pivotData.input;
-                const varianceField = varianceConfig.field === 'category' ? widget.cols[0] : widget.rows[0];
-                const varianceRowsForCurrentKey = lodash.filter(data, row => 
-                    row[varianceField.name] === varianceConfig.name 
-                        && lodash.every(secondArray, (item, index) => row[attrs[index]] === item)
-                );
+    highchartsRenderer.getNewAttrSortingForCol = function (pivotData, sortingOptions) {
+        let rowAttrs, rowKeys, colKeys, colAttrs;
+        rowAttrs = pivotData.rowAttrs;
+        rowKeys = pivotData.rowKeys;
+        colKeys = pivotData.colKeys;
+        colAttrs = pivotData.colAttrs;
 
-                valueForComparison = lodash.reduce(varianceRowsForCurrentKey, (a, d) => a + d[widget.vals[0].name], 0);
-            } else {
-                let getAggregatorParams = [firstArray, secondArray];
 
-                if (lodash.includes(pivotData.rowAttrs, attrs[fieldIndex])) {
-                    getAggregatorParams = lodash.reverse(getAggregatorParams);
-                }
-    
-                let aggregator_subtotal = pivotData.getAggregator(...getAggregatorParams);
+        if (!colAttrs || colAttrs.length == 0) {
+            return null;
+        }
+
+        let values_names_arr = [];
+        let keysArray = sortingOptions.field ? rowKeys : colKeys;
 
-                if (aggregator_subtotal) {
-                    valueForComparison = aggregator_subtotal.value();
+        lodash.forEach(keysArray, function (val) {
+            let firstArray = sortingOptions.field ? [val[0]] : [];
+            let secondArray = sortingOptions.field ? sortingOptions.field.split(highchartsRenderer.delimer) : [val[0]];
+            let aggregator_subtotal = pivotData.getAggregator(firstArray, secondArray);
+
+            if (aggregator_subtotal) {
+                let value_subtotal = aggregator_subtotal.value();
+                if (sortingOptions && sortingOptions.is_absolute && !isNaN(parseFloat(value_subtotal))) {
+                    value_subtotal = Math.abs(value_subtotal);
                 }
+                values_names_arr.push({name: val[0], value: value_subtotal});
             }
+        });
+
+        // ORDERING
+        let sorting_vector = ['asc'];
+        if (sortingOptions && sortingOptions.type == 'largestToSmallest') {
+            sorting_vector = ['desc'];
+        }
+        values_names_arr = lodash.orderBy(values_names_arr, ['value'], sorting_vector);
+
+        // map only names
+        let attr_sorted_values = lodash.map(values_names_arr, 'name');
+        return {name: sortingOptions.field ? rowAttrs[0] : colAttrs[0], values: attr_sorted_values};
+    };
+
+    highchartsRenderer.getNewAttrSortingForRow = function (pivotData, sortingOptions) {
+        let rowAttrs, rowKeys, colKeys, colAttrs;
+        rowAttrs = pivotData.rowAttrs;
+        rowKeys = pivotData.rowKeys;
+        colKeys = pivotData.colKeys;
+        colAttrs = pivotData.colAttrs;
+
+        if (!rowAttrs || rowAttrs.length == 0) {
+            return null;
+        }
+
+        let values_names_arr = [];
+        let keysArray = sortingOptions.field ? colKeys : rowKeys;
+
+        lodash.forEach(keysArray, function (val) {
+            let firstArray = sortingOptions.field ? sortingOptions.field.split(highchartsRenderer.delimer) : [val[0]];
+            let secondArray = sortingOptions.field ? [val[0]] : [];
+            let aggregator_subtotal = pivotData.getAggregator(firstArray, secondArray);
 
-            if (!lodash.isNil(valueForComparison)) {
-                if (sortingOptions && sortingOptions.is_absolute && !isNaN(parseFloat(valueForComparison))) {
-                    valueForComparison = Math.abs(valueForComparison);
+            if (aggregator_subtotal) {
+                let value_subtotal = aggregator_subtotal.value();
+                if (sortingOptions && sortingOptions.is_absolute && !isNaN(parseFloat(value_subtotal))) {
+                    value_subtotal = Math.abs(value_subtotal);
                 }
-                values_names_arr.push({name: secondArray.join(','), value: valueForComparison});
+                values_names_arr.push({name: val[0], value: value_subtotal});
             }
         });
 
@@ -4468,33 +4485,36 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         values_names_arr = lodash.orderBy(values_names_arr, ['value'], sorting_vector);
 
         // map only names
-        return lodash.map(values_names_arr, 'name');
+        let attr_sorted_values = lodash.map(values_names_arr, 'name');
+        return {name: sortingOptions.field ? colAttrs[0] : rowAttrs[0], values: attr_sorted_values};
     };
 
-    highchartsRenderer.generateSortingFunctionByValues = function (sortByValueSettings, pivotData, opts, widget) {
+    highchartsRenderer.generateSortingFunctionByValues = function (sortingOptions, pivotData, opts) {
+        let new_map;
+        let axis = highchartsRenderer.getAxis(sortingOptions.axis, opts);
+        if (axis == 'col_total') {
+            new_map = highchartsRenderer.getNewAttrSortingForCol(pivotData, sortingOptions);
+        } else if (axis == 'row_total') {
+            new_map = highchartsRenderer.getNewAttrSortingForRow(pivotData, sortingOptions);
+        }
+
         let old_sorters_function = opts.sorters;
         if (!old_sorters_function) {
             old_sorters_function = function () {
             };
         }
-        return function (attr) {
-            const sortingOptions = lodash.find(sortByValueSettings, fieldSorting => fieldSorting.name === attr);
-            if (sortingOptions) {
-                const axis = highchartsRenderer.getAxis(_.includes(pivotData.colAttrs, attr) ? 'col_total' : 'row_total', opts);
-                const isColumnSort = axis === 'col_total';
-                const fieldIndex = lodash.findIndex(isColumnSort ? pivotData.colAttrs : pivotData.rowAttrs, name => name === attr);
-                const orderedNamesList = highchartsRenderer.getSortingByValueOrderList(
-                    pivotData,
-                    sortingOptions.sorting,
-                    pivotData[isColumnSort ? 'colKeys' : 'rowKeys'],
-                    pivotData[isColumnSort ? 'colAttrs' : 'rowAttrs'],
-                    fieldIndex,
-                    widget
-                );
-                return $.pivotUtilities.sortAs(orderedNamesList);
-            } else {
-                return old_sorters_function(attr);
+        if (new_map) {
+            var sortAs = $.pivotUtilities.sortAs;
+            let new_sorters_function = function (attr) {
+                if (new_map.name == attr) {
+                    return $.pivotUtilities.sortAs(new_map.values);
+                } else {
+                    return old_sorters_function(attr);
+                }
             }
+            return new_sorters_function;
+        } else {
+            return old_sorters_function;
         }
     };
 
@@ -4698,7 +4718,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         result = null;
         try {
             pivotData = $.pivotUtilities.getPivotDataModel(rowData, opts);
-            pivotData.sortByValueAttrs = [];
             try {
                 if (options && options.onlyOptions) {
                     if (!opts.rendererOptions) {
@@ -4706,15 +4725,9 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                     }
                     opts.rendererOptions.onlyOptions = true;
                 }
-
-                const sortByValueSettings = lodash.filter(
-                    lodash.get(widget, 'options.sortingFields', []),
-                    sortingField => lodash.includes(['field_values', 'variance'], lodash.get(sortingField, 'sorting.sort_by'))
-                );
-
-                if (sortByValueSettings.length) {
-                    pivotData.sortByValueAttrs = lodash.map(sortByValueSettings, fieldSorting => fieldSorting.name);
-                    let new_sorting_function = highchartsRenderer.generateSortingFunctionByValues(sortByValueSettings, pivotData, opts, widget);
+                var totalFilters = lodash.get(opts, 'rendererOptions.total_value_options', null);
+                if (totalFilters && totalFilters.sorting_options) {
+                    let new_sorting_function = highchartsRenderer.generateSortingFunctionByValues(totalFilters.sorting_options, pivotData, opts);
                     opts.sorters = new_sorting_function;
                     optsFiltered.sorters = new_sorting_function;
                     pivotData.sorters = new_sorting_function;
@@ -7071,6 +7084,18 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 value_name: 'is_percentage',
                 default_value: false,
                 hidden: true,
+            }, {
+                element_type: 'checkbox',
+                element_label: 'Sort by variance',
+                value_name: 'sort_by_variance',
+                default_value: false,
+                hidden: true
+            }, {
+                element_type: 'checkbox',
+                element_label: 'Sort by absolute variance',
+                value_name: 'sort_by_absolute_variance',
+                default_value: false,
+                hidden: true
             }]
         },
         'delta_column_for_drill_down': {
@@ -7137,6 +7162,18 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 value_name: 'is_percentage',
                 default_value: false,
                 hidden: true,
+            }, {
+                element_type: 'checkbox',
+                element_label: 'Sort by variance',
+                value_name: 'sort_by_variance',
+                default_value: false,
+                hidden: true
+            }, {
+                element_type: 'checkbox',
+                element_label: 'Sort by absolute variance',
+                value_name: 'sort_by_absolute_variance',
+                default_value: false,
+                hidden: true
             }, {
                 element_type: 'checkbox',
                 element_label: 'Filter zero values',
@@ -8653,9 +8690,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         const isCustomSorting = widget.options.sortingFields && Array.isArray(widget.options.sortingFields) && widget.options.sortingFields.length > 0;
         if (isCustomSorting) {
             lodash.forEach(datesFields, function (field) {
-                const fieldToSort = lodash.find(
-                    widget.options.sortingFields, element => element.id === field.id && lodash.get(element, 'sorting.sort_by') === 'field_items'
-                );
+                const fieldToSort = lodash.find(widget.options.sortingFields, element => element.id === field.id);
                 field.sorting = fieldToSort ? fieldToSort.sorting : field.sorting;
             });
         }
@@ -8737,9 +8772,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             });
         } else if (isCustomSorting) {
             lodash.forEach(rowsAndCols, function (field) {
-                const fieldToSort = lodash.find(
-                    widget.options.sortingFields, element => element.id === field.id && lodash.get(element, 'sorting.sort_by') === 'field_items'
-                );
+                const fieldToSort = lodash.find(widget.options.sortingFields, element => element.id === field.id);
                 field.sorting = fieldToSort ? fieldToSort.sorting : field.sorting;
             });
         }
@@ -8774,9 +8807,61 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         }
 
         /****** END *******/
-        
-        // TODO: Remove. sortingValues looks like lagacy which is not in use neither in webclient nor in renderer
-        if (widget.options && widget.options.sortingValues) {
+
+        if (lodash.has(widget, "options.chartOptions.delta_column") &&
+            widget.options.chartOptions.delta_column.field != '' &&
+            (widget.options.chartOptions.delta_column.sort_by_variance ||
+                widget.options.chartOptions.delta_column.sort_by_absolute_variance) &&
+            widget.rows.length > 0 &&
+            widget.cols.length > 0 &&
+            widget.vals.length
+        ) {
+            let variance_config = widget.options.chartOptions.delta_column;
+            let val_field = widget.vals[0];
+            let field_for_sorting = null;
+            let field_with_variant = null;
+            if (variance_config.field == "series") {
+                field_for_sorting = widget.cols[0];
+                field_with_variant = widget.rows[0];
+            } else if (variance_config.field == "category") {
+                field_for_sorting = widget.rows[0];
+                field_with_variant = widget.cols[0];
+            }
+
+            let data_sorted = lodash.filter(data, function (data_row) {
+                return data_row[field_with_variant.name] == variance_config.name && data_row[field_for_sorting.name] != undefined;
+            });
+
+            const sorting_variance = widget.options.total_value_options && widget.options.total_value_options.sorting_variance === '' ? 'asc' : 'desc';
+
+            if (widget.options.chartOptions.delta_column.sort_by_absolute_variance) {
+                data_sorted = lodash.sortBy(data_sorted, function (o) {
+                    if (sorting_variance === 'desc') {
+                        return Math.abs(o[val_field.name]) * -1;
+                    }
+
+                    return Math.abs(o[val_field.name]) * 1;
+                });
+            } else {
+                data_sorted = lodash.orderBy(data_sorted, [val_field.name], [sorting_variance]);
+            }
+
+            let values_for_sort = lodash.map(data_sorted, function (data_row) {
+                return data_row[field_for_sorting.name];
+            });
+
+            values_for_sort = lodash.uniq(values_for_sort);
+
+            if (values_for_sort.length > 0) {
+                let field = lodash.find(datesFields, {name: field_for_sorting.name});
+                if (field) {
+                    field.values = values_for_sort;
+                    field.sorting = null;
+                } else {
+                    datesFields.push({name: field_for_sorting.name, values: values_for_sort});
+                }
+            }
+        } else if (widget.options && widget.options.sortingValues) {
             var field = lodash.find(datesFields, {name: widget.options.sortingValues.field});
             if (field) {
                 field.values = widget.options.sortingValues.values;

package/src/pivottable.js

@@ -577,7 +577,6 @@ let initPivotTable = function($, window, document) {
         l_mapping = {};
         for (i in order) {
             x = order[i];
-            if (order[i] === null) x = '[null]';
             mapping[x] = i;
             if (typeof x === "string") {
                 l_mapping[x.toLowerCase()] = i;

package/tests/highcharts_renderer.test.js

@@ -1323,264 +1323,6 @@ describe('highcharts_renderer', () => {
         });
     });
 
-    describe("function updateBackwardCompatibleWidgetOptions", () => {
-        it("should delete chart 'hideLegends' option if exists and true", () => {
-            const options = {
-                chartOptions: {
-                    chart: {
-                        hideLegends: true
-                    }
-                },
-                comboOptions: {}
-            };
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'line-chart')
-            expect(options.chartOptions.legends_position.value).toBe('none');
-            expect(options.chartOptions.chart.hideLegends).toBe(undefined);
-        });
-
-        it("should move error_policy chart option to advanced chart option", () => {
-            const error_policy = 'test_policy';
-            const options = {
-                chartOptions: {
-                    error_policy: {
-                        error_policy: error_policy
-                    }
-                },
-                comboOptions: {}
-            };
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'line-chart')
-            expect(options.chartOptions.advanced.from_latest).toBe('');
-            expect(options.chartOptions.advanced.error_policy).toBe(error_policy);
-            expect(options.chartOptions.error_policy).toBe(undefined);
-            expect(options.chartOptions.from_version).toBe(undefined);
-        });
-
-        it("should move from_version chart option to advanced chart option", () => {
-            const from_version = 'from_version';
-            const options = {
-                chartOptions: {
-                    from_version: {
-                        value: from_version
-                    }
-                },
-                comboOptions: {}
-            };
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'line-chart')
-            expect(options.chartOptions.advanced.from_latest).toBe(from_version);
-            expect(options.chartOptions.advanced.error_policy).toBe('None');
-            expect(options.chartOptions.error_policy).toBe(undefined);
-            expect(options.chartOptions.from_version).toBe(undefined);
-        });
-
-        it("should remove chart label style option", () => {
-            const options = {
-                chartOptions: {
-                    label: {
-                        style: 'color: red;'
-                    }
-                },
-                comboOptions: {}
-            };
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'line-chart')
-            expect(options.chartOptions.label.style).toBe(undefined);
-        });
-
-        it("should remove chart label_pie style option", () => {
-            const options = {
-                chartOptions: {
-                    label_pie: {
-                        style: 'color: red;'
-                    }
-                },
-                comboOptions: {}
-            };
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'line-chart')
-            expect(options.chartOptions.label_pie.style).toBe(undefined);
-        });
-
-        it("update pie-chart label options if only_value", () => {
-            const options = {
-                chartOptions: {
-                    label: {
-                        only_value: true
-                    }
-                },
-                comboOptions: {}
-            };
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'pie-chart')
-            expect(options.chartOptions.label_pie).toEqual({
-                show_percentage_in_labels: false,
-                show_value_in_labels: true
-            });
-            expect(options.chartOptions.label).toBe(undefined);
-        });
-
-        it("update pie-chart label options if only_percentage", () => {
-            const options = {
-                chartOptions: {
-                    label: {
-                        only_percentage: true
-                    }
-                },
-                comboOptions: {}
-            };
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'pie-chart')
-            expect(options.chartOptions.label_pie).toEqual({
-                show_percentage_in_labels: true,
-                show_value_in_labels: false
-            });
-            expect(options.chartOptions.label).toBe(undefined);
-        });
-
-        it("update pie-chart label options if show", () => {
-            const options = {
-                chartOptions: {
-                    label: {
-                        show: true
-                    }
-                },
-                comboOptions: {}
-            };
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'pie-chart');
-            expect(options.chartOptions.label_pie).toEqual({
-                show: true,
-                show_percentage_in_labels: true,
-                show_value_in_labels: true
-            });
-            expect(options.chartOptions.label).toBe(undefined);
-        });
-
-        it("should do nothing if pie chart without 'only_percentage/only_value/show'", () => {
-            const options1 = {
-                chartOptions: { label: { } }, comboOptions: {}
-            };
-            const options2 = {
-                chartOptions: { }, comboOptions: {}
-            };
-
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options1, 'pie-chart');
-            expect(options1).toEqual({
-                chartOptions: { label_pie: {} }, comboOptions: {}
-            });
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options2, 'pie-chart');
-            expect(options2).toEqual({
-                chartOptions: { }, comboOptions: {}
-            });
-        });
-
-        it("should create comboOptions for different series types", () => {
-            const options = {
-                chartOptions: {
-                    delta_column: {
-                        field: 'series',
-                        name: 'TEST_test',
-                        same_yaxis: true,
-                        is_percentage: true,
-                    }
-                }
-            };
-
-            const seriesTypes = ['line', 'spline', 'area', 'areaspline', 'scatter', 'column', 'default'];
-            const seriesTypesMap = ['line-chart', 'line-chart-smooth', 'area-chart', 'area-chart-smooth', 'scatter-chart', 'column-chart', 'scatter-chart'];
-
-            seriesTypes.forEach((type, index) => {
-                const currentOptions = lodash.cloneDeep(options);
-                currentOptions.chartOptions.delta_column.chart = type;
-                highchartsRenderer.updateBackwardCompatibleWidgetOptions(currentOptions, null);
-                expect(currentOptions.comboOptions).toEqual({
-                    secondaryAxisSettings: {
-                        name: 'TESTtest',
-                        max: null,
-                        min: null,
-                        is_percentage: true
-                    },
-                    seriesOptions: [{
-                        series: 'TEST_test',
-                        secondaryAxis: false,
-                        chartType: seriesTypesMap[index]
-                    }]
-                });
-            });
-        });
-
-        it("should create comboOptions without series options if no delta_column field", () => {
-            const options = {};
-            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, null);
-            expect(options).toEqual({
-                comboOptions :{
-                    secondaryAxisSettings: {
-                        name: 'Secondary Axis',
-                        max: null,
-                        min: null,
-                        is_percentage: false,
-                    },
-                    seriesOptions: []
-                }
-            });
-        });
-    });
-
-    describe("function setMissingWidgetOptions", () => {
-        it("should return do nothing if there are no chartOptions", () => {
-            const options = { testProp: true };
-            highchartsRenderer.setMissingWidgetOptions(options, null)
-            expect(options).toEqual({ testProp: true });
-        });
-
-        it("should merge current chart options with default", () => {
-            spyOn(highchartsRenderer, 'getDefaultValueForChart').and.returnValue({
-                array: [1, 3, 5],
-                newProp: 'defaultNew',
-                existingProp: 'defaultExist',
-                obj: {
-                    newProp: 'defaultNew',
-                    existingProp: 'defaultExist',
-                },
-                newObj: {
-                    newProp: 'defaultNew',
-                }
-            });
-            const options = {
-                chartOptions: {
-                    array: [2, 5, 6],
-                    existingProp: 'exist',
-                    obj: {
-                        existingProp: 'exist',
-                    }
-                }
-            };
-            highchartsRenderer.setMissingWidgetOptions(options, 'line-chart')
-            expect(options.chartOptions).toEqual({
-                array: [2, 5, 6],
-                existingProp: "exist",
-                newObj: { newProp: "defaultNew" },
-                newProp: "defaultNew",
-                obj: {
-                    existingProp: "exist",
-                    newProp: "defaultNew"
-                }
-            });
-        });
-    });
-
-    describe('function getChartOptionsBySubType', () => {
-        it('returns null for rich_text subtype', () => {
-            const result = highchartsRenderer.getChartOptionsBySubType('rich_text');
-            expect(result).toBe(highchartsRenderer.richTextSubType);
-        });
-
-        it('returns chart options for existing subtype', () => {
-            const result = highchartsRenderer.getChartOptionsBySubType('line-chart');
-            expect(result.type).toEqual('line-chart');
-            expect(result.suboptions.length).toEqual(highchartsRenderer.chartsData[0].subtypes[0].suboptions.length);
-        });
-
-        it('returns null for non-existing subtype', () => {
-            const result = highchartsRenderer.getChartOptionsBySubType('nonExistingType');
-            expect(result).toBe(null);
-        });
-    });
-
     describe('function aggregators', () => {
         const aggregatorsIds = ['SUM', 'COUNT', 'COUNT_UNIQUE', 'UNIQUE_VALUES', 'AVG', 'MIN', 'MAX'];
 
@@ -2711,390 +2453,6 @@ describe('highcharts_renderer', () => {
         });
     });
 
-    describe('function getDefaultValueForChart', () => {
-        it('should return empty value for rich_text type', () => {
-            expect(highchartsRenderer.getDefaultValueForChart('rich_text', {})).toEqual({});
-        });
-
-        it('should return default value for line-chart type if existing options are empty', () => {
-            const res = highchartsRenderer.getDefaultValueForChart('line-chart', {});
-            expect(Object.keys(res).length).toEqual(highchartsRenderer.chartsData[0].subtypes[0].suboptions.length);
-        });
-    });
-
-    describe('function getCommonChartOptions', () => {
-        const TOOLTIP_DEFAULT_OPTIONS = {
-            borderColor: '#fff',
-            shadow: {
-                color: '#9199b4',
-                width: 10,
-                opacity: 0.05
-            },
-            style: {
-                fontSize: '12',
-                fontFamily: 'Poppins',
-                color: '#545a6b',
-            },
-            enabled: true,
-        };
-
-        it('should return empty object if additionalOptions is null or undefined', () => {
-            expect(highchartsRenderer.getCommonChartOptions(null)).toEqual({});
-            expect(highchartsRenderer.getCommonChartOptions(undefined)).toEqual({});
-        });
-
-        it('should return empty tooltip if additionalOptions has no tooltips', () => {
-            const additionalOptions = { };
-            expect(highchartsRenderer.getCommonChartOptions(additionalOptions)).toEqual({});
-        });
-
-        it('should return tooltip with default options if tooltips.show is not defined', () => {
-            const additionalOptions = { tooltips: {} };
-            const expected = { tooltip: TOOLTIP_DEFAULT_OPTIONS };
-            expect(highchartsRenderer.getCommonChartOptions(additionalOptions)).toEqual(expected);
-        });
-
-        it('should return tooltip with custom style options', () => {
-            const additionalOptions = {
-                tooltips: {
-                    show: true,
-                    font_size: 14,
-                    font_style: 'Arial',
-                    font_color: '#333',
-                }
-            };
-            const expected = {
-                tooltip: {
-                    borderColor: '#fff',
-                    shadow: {
-                        color: '#9199b4',
-                        width: 10,
-                        opacity: 0.05
-                    },
-                    style: {
-                        fontSize: 14,
-                        fontFamily: 'Arial',
-                        color: '#333',
-                    },
-                    enabled: true,
-                }
-            };
-            expect(highchartsRenderer.getCommonChartOptions(additionalOptions)).toEqual(expected);
-        });
-
-        it('should return tooltip with custom style options and show set to false', () => {
-            const additionalOptions = {
-                tooltips: {
-                    show: false,
-                    font_size: 14,
-                    font_style: 'Arial',
-                    font_color: '#333',
-                }
-            };
-            const expected = {
-                tooltip: {
-                    borderColor: '#fff',
-                    shadow: {
-                        color: '#9199b4',
-                        width: 10,
-                        opacity: 0.05
-                    },
-                    style: {
-                        fontSize: 14,
-                        fontFamily: 'Arial',
-                        color: '#333',
-                    },
-                    enabled: false,
-                }
-            };
-            expect(highchartsRenderer.getCommonChartOptions(additionalOptions)).toEqual(expected);
-        });
-    });
-    
-    describe('function getDataLabelsStyle', () => {
-        it('returns default style if additionalOptions is empty', () => {
-            const additionalOptions = {};
-            const defaultStyle = { color: '#333', fontWeight: 'bold' };
-            const expected = defaultStyle;
-            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
-            expect(actual).toEqual(expected);
-        });
-
-        it('returns default style if additionalOptions does not contain a label option key', () => {
-            const additionalOptions = { backgroundColor: '#fff' };
-            const defaultStyle = { color: '#333', fontWeight: 'bold' };
-            const expected = defaultStyle;
-            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
-            expect(actual).toEqual(expected);
-        });
-
-        it('returns style merged with defaultStyle if both exist', () => {
-            const additionalOptions = { label_1: { font_size: '16px' } };
-            const defaultStyle = { color: '#333', fontWeight: 'bold' };
-            const expected = { color: '#333', fontWeight: 'bold', fontSize: '16px' };
-            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
-            expect(actual).toEqual(expected);
-        });
-
-        it('returns style with font size and font family if they exist', () => {
-            const additionalOptions = { label_1: { font_size: '16px', font_style: 'Helvetica' } };
-            const defaultStyle = { color: '#333', fontWeight: 'bold' };
-            const expected = { color: '#333', fontWeight: 'bold', fontSize: '16px', fontFamily: 'Helvetica' };
-            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
-            expect(actual).toEqual(expected);
-        });
-
-        it('returns style only with font size and font family if defaultStyle has wrong format', () => {
-            const additionalOptions = { label_1: { font_size: '16px', font_style: 'Helvetica' } };
-            const defaultStyle = "{ color: '#333', fontWeight: 'bold' }";
-            const expected = { fontSize: '16px', fontFamily: 'Helvetica' };
-            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
-            expect(actual).toEqual(expected);
-        });
-
-        it('returns style only with font size and font family if defaultStyle is null', () => {
-            const additionalOptions = { label_1: { font_size: '16px', font_style: 'Helvetica' } };
-            const defaultStyle = null;
-            const expected = { fontSize: '16px', fontFamily: 'Helvetica' };
-            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
-            expect(actual).toEqual(expected);
-        });
-    });
-
-    describe('function getDataLabelsOptions', () => {
-        const defaultDataLabels = {
-            color: "#151a41",
-            enabled: true,
-            style: {
-                fontFamily: "Poppins",
-                fontSize: "12px",
-                fontWeight: "bold"
-            }
-        };
-
-        it('should return chartOptions with default data label options if additionalOptions is not defined', () => {
-            const chartOptions = {
-                dataLabels: {
-                    enabled: true,
-                    style: {
-                        fontSize: '12px',
-                        fontWeight: 'bold',
-                    },
-                },
-            };
-            const result = highchartsRenderer.getDataLabelsOptions(undefined, chartOptions);
-            expect(result).toEqual(chartOptions);
-            expect(result.dataLabels).toEqual(defaultDataLabels);
-        });
-
-        it('should return chartOptions with merged data label options if additionalOptions does not contain a label key', () => {
-            const additionalOptions = {
-                option1: 'value1',
-                option2: 'value2',
-                option3: 'value3',
-            };
-            const chartOptions = {
-                dataLabels: {
-                    enabled: true,
-                    style: {
-                        fontSize: '13px',
-                        fontWeight: 'normal',
-                    },
-                },
-            };
-            const expected = {
-                dataLabels: {
-                    color: "#151a41",
-                    enabled: true,
-                    style: {
-                        fontFamily: "Poppins",
-                        fontSize: "13px",
-                        fontWeight: "normal"
-                    }
-                }
-            };
-            const result = highchartsRenderer.getDataLabelsOptions(additionalOptions, chartOptions);
-            expect(result).toEqual(expected);
-        });
-
-        it('should return chartOptions with merged data label options if additionalOptions contains a label key', () => {
-            const additionalOptions = {
-                label_option: {
-                    font_color: 'red',
-                },
-            };
-            const chartOptions = {
-                dataLabels: {
-                    enabled: true,
-                    style: {
-                        fontSize: '15px',
-                        fontWeight: 'bold',
-                    },
-                },
-            };
-            const expected = {
-                dataLabels: {
-                    color: "red",
-                    enabled: true,
-                    style: {
-                        fontFamily: "Poppins",
-                        fontSize: "15px",
-                        fontWeight: "bold"
-                    }
-                }
-            };
-            const result = highchartsRenderer.getDataLabelsOptions(additionalOptions, chartOptions);
-            expect(result).toEqual(expected);
-        });
-    });
-    
-    describe('function getLabelOptionKey', () => {
-        it('should return null if additionalOptions is not defined', () => {
-            const result = highchartsRenderer.getLabelOptionKey(undefined);
-            expect(result).toBeNull();
-        });
-
-        it('should return null if no label key is found in additionalOptions', () => {
-            const additionalOptions = {
-                option1: 'value1',
-                option2: 'value2',
-                option3: 'value3',
-            };
-            const result = highchartsRenderer.getLabelOptionKey(additionalOptions);
-            expect(result).toBeNull();
-        });
-
-        it('should return the label key if found in additionalOptions', () => {
-            const additionalOptions = {
-                option1: 'value1',
-                label_option: 'value2',
-                option3: 'value3',
-            };
-            const result = highchartsRenderer.getLabelOptionKey(additionalOptions);
-            expect(result).toBe('label_option');
-        });
-
-        it('should return the first label key if multiple label keys are found in additionalOptions', () => {
-            const additionalOptions = {
-                label_option1: 'value1',
-                option1: 'value2',
-                label_option2: 'value3',
-            };
-            const result = highchartsRenderer.getLabelOptionKey(additionalOptions);
-            expect(result).toBe('label_option1');
-        });
-    });
-    
-    describe('function getDefaultValueForSubOptions', () => {
-        const suboptions = {
-            option1: {
-                category_type: 'type1',
-                elements: [
-                    {
-                        value_name: 'value1',
-                        element_type: 'text',
-                        default_value: 'default1',
-                    },
-                    {
-                        value_name: 'value2',
-                        element_type: 'number',
-                        default_value: 42,
-                    },
-                    {
-                        value_name: 'value3',
-                        element_type: 'devider',
-                    },
-                ],
-            },
-            option2: {
-                category_type: 'type2',
-                elements: [
-                    {
-                        value_name: 'value1',
-                        element_type: 'text',
-                        default_value: 'default2',
-                    },
-                    {
-                        value_name: 'value2',
-                        element_type: 'number',
-                        default_value: 23,
-                    },
-                    {
-                        value_name: 'value3',
-                        element_type: 'devider',
-                    },
-                ],
-            },
-            option3: {
-                category_type: 'type3',
-                elements: [
-                    {
-                        value_name: 'value1',
-                        element_type: 'text',
-                        default_value: { val: 1 },
-                    }
-                ],
-            },
-        };
-        let tempSubOptions = null;
-
-        beforeAll(() => {
-            tempSubOptions = highchartsRenderer.suboptions;
-            highchartsRenderer.suboptions = suboptions;
-        });
-
-        afterAll(() => {
-            highchartsRenderer.suboptions = tempSubOptions;
-        });
-
-        it('should return an empty object if option type is not found', () => {
-            const type = 'invalid_type';
-            const existing_options = {};
-            const result = highchartsRenderer.getDefaultValueForSubOptions(type, existing_options);
-            expect(result).toEqual({});
-        });
-
-        it('should return default values for all elements in suboption', () => {
-            const type = 'type1';
-            const existing_options = {};
-            const result = highchartsRenderer.getDefaultValueForSubOptions(type, existing_options);
-            expect(result).toEqual({
-                value1: 'default1',
-                value2: 42,
-            });
-        });
-
-        it('should use existing options if available', () => {
-            const type = 'type1';
-            const existing_options = {
-                type1: {
-                    value1: 'existing1',
-                    value2: 99,
-                },
-            };
-            const result = highchartsRenderer.getDefaultValueForSubOptions(type, existing_options);
-            expect(result).toEqual({
-                value1: 'existing1',
-                value2: 99,
-            });
-        });
-
-        it('should ignore elements with type "devider"', () => {
-            const type = 'type1';
-            const existing_options = {};
-            const result = highchartsRenderer.getDefaultValueForSubOptions(type, existing_options);
-            expect(result).not.toHaveProperty('value3');
-        });
-
-        it('should clone default value if it is an object', () => {
-            const type = 'type3';
-            const existing_options = {};
-            const result = highchartsRenderer.getDefaultValueForSubOptions(type, existing_options);
-            expect(result.value1).toEqual(suboptions.option3.elements[0].default_value);
-            expect(result.value1).not.toBe(suboptions.option3.elements[0].default_value);
-        });
-    });
-    
     describe('function getChartAxisLabel', () => {
         it('should return default value', () => {
             expect(highchartsRenderer.getChartAxisLabel('invalidType')).toBe('Axis (Category)')