@datarailsshared/dr_renderer 1.3.59 → 1.4.5

package/src/seriesPointStyles-helper.js

@@ -30,7 +30,7 @@ function setInitialPointStyles(opts, series) {
                 const isSelected =
                     item && opts.selectedPoint &&
                     item.initialName === opts.selectedPoint.initialName &&
-                    item.y.toFixed(2) === opts.selectedPoint.y.toFixed(2);
+                    item.y != null && item.y.toFixed(2) === opts.selectedPoint.y != null && opts.selectedPoint.y.toFixed(2);
                 item = Object.assign(item, getSeriesPointStyles(isSelected));
             });
         }

package/src/smart_queries_helper.js

@@ -5,37 +5,40 @@ const DR_SCENARIO = {
     Forecast: 'Forecast',
 };
 
-function createSingleDataSeriesForForecast(chart_series, chartOptions, pivotData) {
+function createSingleDataSeriesForForecast(chart_series, chartOptions, pivotData, isChartCombiLine) {
+  if (!chartOptions || !chartOptions.chart) return null;
+
   const { actuals, forecast, smart_query } = chartOptions.chart;
   const input = pivotData.input;
 
-  const hasSQActuals = input.some(item => item.Scenario && item.Scenario.indexOf(DR_SCENARIO.SQ_Actuals) !== -1);
+  const hasSQActuals = lodash.some(input, item => lodash.includes(item.Scenario, DR_SCENARIO.SQ_Actuals));
   chartOptions.isSmartQueriesEnabled = hasSQActuals;
   if (!smart_query || !hasSQActuals) return null;
 
   const midMonthOffset = 0.5
-  return chart_series.length === 1
-    ? buildChartSeriesFromPivotInputOnly(input, actuals, forecast, midMonthOffset)
-    : buildChartSeriesFromSeries(chart_series, actuals, forecast, midMonthOffset);
+    return chart_series.length === 1
+        ? buildChartSeriesFromPivotInputOnly(input, actuals, forecast, midMonthOffset, chart_series[0].name)
+        : (isChartCombiLine ?
+            buildChartSeriesForMultipleSeriesCombinedLine(chart_series, input, actuals, forecast, midMonthOffset) :
+            buildChartSeriesFromSeries(chart_series, actuals, forecast, midMonthOffset));
 }
 
-function buildChartSeriesFromPivotInputOnly(input, actuals, forecast, midMonthOffset) {
+function buildChartSeriesFromPivotInputOnly(input, actuals, forecast, midMonthOffset, name) {
   const filtered = input.filter(item =>
-    (item.Scenario === DR_SCENARIO.SQ_Actuals || item.Scenario === DR_SCENARIO.Forecast) &&
-    item.Amount !== 0
+    (item.Scenario === DR_SCENARIO.SQ_Actuals || item.Scenario === DR_SCENARIO.Forecast) && !!item['Reporting Month']
   );
 
-  const data = filtered.map(item => ({
+  const data = lodash.map(filtered, item => ({
     y: item.Amount,
-    name: item.Reporting_Month,
-    initialName: item.Reporting_Month,
+    name: item['Reporting Month'],
+    initialName: item['Reporting Month'],
     type: item.Scenario,
-  })).sort((a, b) => new Date(a.name) - new Date(b.name));
+  })).sort((a, b) => sortRowValuesByName(a, b));
 
-  const sqCount = input.filter(item => item.Scenario === DR_SCENARIO.SQ_Actuals).length;
+  const sqCount = lodash.filter(input, item => item.Scenario === DR_SCENARIO.SQ_Actuals).length;
 
   return {
-    name: "Forecast Smart Query",
+    name,
     data,
     zoneAxis: "x",
     zones: [
@@ -45,6 +48,51 @@ function buildChartSeriesFromPivotInputOnly(input, actuals, forecast, midMonthOf
   };
 }
 
+function buildChartSeriesForMultipleSeriesCombinedLine(chart_series, input, actuals, forecast, midMonthOffset) {
+    const resultingSeries = [];
+    for (let i = 0; i < chart_series.length; i++) {
+        const series = chart_series[i];
+        if (!series || !series.data || !series.data.length) continue;
+
+        const data = lodash.chain(input)
+            .filter(item => item['Scenario Cycle'] === series.name &&
+          (item['Scenario'] === DR_SCENARIO.SQ_Actuals || item['Scenario'] === DR_SCENARIO.Forecast) && !!item['Reporting Month'])
+            .map(item => ({
+              y: item.Amount,
+              name: item['Reporting Month'],
+              initialName: item['Reporting Month'],
+              type: item.Scenario,
+            }))
+            .value().sort((a, b) => {
+                return sortRowValuesByName(a, b);
+            });
+        if (!data.length) {
+            resultingSeries.push(series);
+            continue;
+        }
+
+        const sqCount = lodash.filter(data, item => item.type === DR_SCENARIO.SQ_Actuals).length;
+        resultingSeries.push(
+            {
+                name: series.name,
+                data,
+                zoneAxis: "x",
+                zones: [
+                    { value: sqCount - midMonthOffset, dashStyle: actuals },
+                    { dashStyle: forecast },
+                ],
+            }
+        )
+    }
+    return resultingSeries;
+}
+
+function sortRowValuesByName(rowValueA, rowValueB) {
+    const aDate = new Date(rowValueA.name);
+    const bDate = new Date(rowValueB.name);
+    return !isNaN(aDate.getTime()) && !isNaN(bDate.getTime()) ? aDate - bDate : rowValueA.name.localeCompare(rowValueB.name);
+}
+
 function buildChartSeriesFromSeries(chart_series, actuals, forecast, midMonthOffset) {
   const seriesA = lodash.find(chart_series, s => s.name && lodash.includes(s.name, DR_SCENARIO.SQ_Actuals));
   const seriesB = lodash.find(chart_series, s => s.name && lodash.includes(s.name, DR_SCENARIO.Forecast));

package/src/types/errors.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Enum for dr renderer error codes.
+ */
+export type RendererErrorCodes = number;
+export namespace RendererErrorCodes {
+    let NoDataError: number;
+    let TooMuchDataError: number;
+    let DataConflictError: number;
+    let GaugeConfigurationError: number;
+    let GenericRenderingError: number;
+    let GenericComputationalError: number;
+}
+/**
+ * Base error class for all renderer-related errors.
+ * @class BaseRendererError
+ * @extends Error
+ */
+export class BaseRendererError extends Error {
+    /**
+     * Creates a new BaseRendererError instance.
+     * @param {Object} config - Error configuration object
+     * @param {number} config.code - Unique error code
+     * @param {string} config.title - Error title/message
+     * @param {Object} [config.options={}] - Additional error options or context
+     */
+    constructor({ code, title, options }: {
+        code: number;
+        title: string;
+        options?: Object | undefined;
+    });
+    /**
+     * Error code for identification purposes
+     * @type {number}
+     */
+    code: number;
+    /**
+     * Human-readable error title
+     * @type {string}
+     */
+    title: string;
+    /**
+     * Additional options or context for the error
+     * @type {Object}
+     */
+    options: Object;
+}
+/**
+ * Error thrown when there is too much data to render efficiently.
+ * @class TooMuchDataError
+ * @extends BaseRendererError
+ */
+export class TooMuchDataError extends BaseRendererError {
+    /**
+     * Creates a new TooMuchDataError instance.
+     * This error is thrown when the dataset exceeds the renderer's capacity
+     * and requires the user to edit the widget.
+     */
+    constructor();
+}
+/**
+ * Error thrown when no data is available.
+ * @class NoDataError
+ * @extends BaseRendererError
+ */
+export class NoDataError extends BaseRendererError {
+    /**
+     * Creates a new NoDataError instance.
+     * This error is thrown when a widget or component has no available data.
+     */
+    constructor();
+}
+/**
+ * Error thrown when there are conflicts in the data being processed.
+ * @class DataConflictError
+ * @extends BaseRendererError
+ */
+export class DataConflictError extends BaseRendererError {
+    /**
+     * Creates a new DataConflictError instance.
+     * @param {Object} [options] - Additional context about the data conflict.
+     */
+    constructor(options?: Object);
+}
+/**
+ * Error thrown when a gauge chart is missing required info.
+ * @class GaugeConfigurationError
+ * @extends BaseRendererError
+ */
+export class GaugeConfigurationError extends BaseRendererError {
+    /**
+     * Creates a new GaugeConfigurationError instance.
+     */
+    constructor();
+}
+/**
+ * Generic error for rendering failures in PivotTable components.
+ * @class GenericRenderingError
+ * @extends BaseRendererError
+ */
+export class GenericRenderingError extends BaseRendererError {
+    /**
+     * Creates a new GenericRenderingError instance.
+     * This error is thrown when an unexpected error occurs during
+     * the rendering process of PivotTable results.
+     */
+    constructor();
+}
+/**
+ * Generic error for computational failures in PivotTable components.
+ * @class GenericComputationalError
+ * @extends BaseRendererError
+ */
+export class GenericComputationalError extends BaseRendererError {
+    /**
+     * Creates a new GenericComputationalError instance.
+     * This error is thrown when an unexpected error occurs during
+     * the computation process of PivotTable results.
+     */
+    constructor();
+}

package/src/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './graph-table-renderer';
+export * from './errors'

package/src/value.formatter.js

@@ -0,0 +1,41 @@
+const lodash = require('lodash');
+
+function getAggregatorPercentageValueIfRequired(value, render_options, data, rowKey, colKey) {
+    const deltaColumn = lodash.get(render_options, 'chartOptions.delta_column', null);
+    const isPercentage = lodash.get(render_options, 'comboOptions.secondaryAxisSettings.is_percentage', false) || deltaColumn && deltaColumn.is_percentage;
+    const currentRowName = rowKey && rowKey.length ? String(rowKey[0]) : '';
+    const isVariance = deltaColumn && currentRowName.replace('_', '').toLowerCase() === deltaColumn.name.replace('_', '').toLowerCase();
+    const baseRowKey = data && data.rowKeys && data.rowKeys.length ? data.rowKeys[0] : null;
+    const currentColKey = colKey ? colKey : [];
+    const agg = data && baseRowKey ? data.getAggregator(baseRowKey, currentColKey) : null;
+    
+    if (isPercentage && isVariance && baseRowKey && agg) {
+        if (deltaColumn && isAbsoluteValue(deltaColumn.formula)) {
+            value = getRelatedValue(value, agg.value());
+        }
+        
+        return Math.round(value * 100) + '%';
+    }
+
+    return null;
+};
+
+function getRelatedValue(value, baseValue) {
+    if (!baseValue)
+        return value < 0 ? -1 : 1;
+
+    return value / baseValue;
+};
+
+function isAbsoluteValue(formula) {
+    if (!formula)
+        return false;
+    
+    return !lodash.includes(formula.replace(/\s+/g, ''), '/');
+};
+
+module.exports = {
+    getAggregatorPercentageValueIfRequired,
+    getRelatedValue,
+    isAbsoluteValue
+};

package/tests/dr-renderer-helpers.test.js

@@ -73,6 +73,39 @@ describe('dr-renderer-helpers', () => {
             expect(drRendererHelpers.mergeDeep({ a: 1 }, 'string')).toEqual({ a: 1 });
         });
 
+        it('does not mutate sources', () => {
+            const src1 = { a: { x: 1 }, arr: [1,2] };
+            const src2 = { a: { y: 2 }, arr: [3] };
+            const res = drRendererHelpers.mergeDeep({}, src1, src2);
+
+            res.a.x = 42;
+            res.arr.push(99);
+
+            expect(src1).toEqual({ a: { x: 1 }, arr: [1,2] });
+            expect(src2).toEqual({ a: { y: 2 }, arr: [3] });
+        });
+
+        it('replaces arrays by clone, not by reference', () => {
+            const src = { a: [1,2,3] };
+            const res = drRendererHelpers.mergeDeep({}, src);
+            expect(res.a).not.toBe(src.a);
+        });
+
+        it('ignores non-plain objects', () => {
+            const d = new Date();
+            const res = drRendererHelpers.mergeDeep({}, { when: d });
+            expect(res.when).toBe(d);
+        });
+
+        it('last source wins (and arrays are replaced)', () => {
+            const res = drRendererHelpers.mergeDeep(
+                { a: { x: 1 }, arr: [1] },
+                { a: { y: 2 }, arr: [2] },
+                { a: { z: 3 }, arr: [3] },
+            );
+            expect(res).toEqual({ a: { x:1, y:2, z:3 }, arr: [3] });
+        });
+
         it('should not merge arrays and replace instead', () => {
             expect(drRendererHelpers.mergeDeep({
                 a: [1, 2, 3]

package/tests/dr_gauge_chart.test.js

@@ -23,6 +23,7 @@ DrGaugeChart.highchartsRenderer = {
     }),
     disableChartAnimations: jest.fn((value) => disableChartAnimation = value),
     chartAnimationsDisabled: jest.fn(() => disableChartAnimation),
+    hasFeature: jest.fn().mockReturnValue(false),
 };
 
 const mockAggregationValue = 1000;
@@ -309,6 +310,93 @@ describe("DrGaugeChart", () => {
                 },
             ]);
         });
+
+        it("scales by needle magnitude when goal is 0 in percentage mode", () => {
+            chart.value = 250;
+            expect(
+                chart.createPlotBands({
+                    isAbsoluteValue: false,
+                    gauge: { thickness: 10 },
+                    goal: { value: 0 },
+                    segments: [
+                        { from: 0, to: 50, color: "red", title: "Title 1" },
+                        { from: 50, to: 100, color: "blue", title: "Title 2" },
+                    ],
+                })
+            ).toEqual([
+                { from: 0, to: 125, color: "red", thickness: 10, title: "Title 1" },
+                { from: 125, to: 250, color: "blue", thickness: 10, title: "Title 2" },
+            ]);
+        });
+
+        it("scales by absolute needle magnitude when goal is not a number", () => {
+            const featureSpy = jest
+                .spyOn(DrGaugeChart.highchartsRenderer, "hasFeature")
+                .mockReturnValue(true);
+
+            chart.value = -300;
+            const res = chart.createPlotBands({
+                isAbsoluteValue: false,
+                gauge: { thickness: 8 },
+                goal: { value: undefined },
+                segments: [
+                    { from: 0, to: 50, color: "#1", title: "A" },
+                    { from: 50, to: 100, color: "#2", title: "B" },
+                ],
+            });
+
+            expect(res).toEqual([
+                { from: 0, to: 150, color: "#1", thickness: 8, title: "A" },
+                { from: 150, to: 300, color: "#2", thickness: 8, title: "B" },
+            ]);
+
+            featureSpy.mockRestore();
+        });
+
+        it("normalizes bands when goal is negative in percentage mode", () => {
+            const res = chart.createPlotBands({
+                isAbsoluteValue: false,
+                gauge: { thickness: 12 },
+                goal: { value: -1000 },
+                segments: [
+                    { from: 0, to: 50, color: "r", title: "S1" },
+                    { from: 50, to: 100, color: "b", title: "S2" },
+                ],
+            });
+
+            expect(res[0].from).toBe(-500);
+            expect(Math.abs(res[0].to)).toBe(0);
+            expect(res[0].color).toBe("r");
+            expect(res[0].thickness).toBe(12);
+            expect(res[0].title).toBe("S1");
+
+            expect(res[1]).toEqual({ from: -1000, to: -500, color: "b", thickness: 12, title: "S2" });
+        });
+
+        it("does not clamp last segment when dynamic goal feature is enabled", () => {
+            const featureSpy = jest
+                .spyOn(DrGaugeChart.highchartsRenderer, "hasFeature")
+                .mockReturnValue(true);
+
+            const res = chart.createPlotBands({
+                isAbsoluteValue: true,
+                gauge: { thickness: 10 },
+                goal: { value: 1800 },
+                segments: [
+                    { from: 100, to: 200, color: "red", title: "Title 1" },
+                    { from: 200, to: 400, color: "blue", title: "Title 2" },
+                    { from: 400, to: 800, color: "green", title: "Title 3" },
+                ],
+            });
+
+            expect(res).toEqual([
+                { from: 100, to: 200, color: "red", thickness: 10, title: "Title 1" },
+                { from: 200, to: 400, color: "blue", thickness: 10, title: "Title 2" },
+                { from: 400, to: 800, color: "green", thickness: 10, title: "Title 3" },
+            ]);
+
+            featureSpy.mockRestore();
+        });
     });
 
     describe("createTicks", () => {

package/tests/errors.test.js

@@ -0,0 +1,157 @@
+const {
+    BaseRendererError,
+    NoDataError,
+    TooMuchDataError,
+    DataConflictError,
+    GaugeConfigurationError,
+    GenericRenderingError,
+    GenericComputationalError
+} = require('../src/errors');
+
+describe('Error Classes', () => {
+    describe('BaseRendererError', () => {
+        it('should create instance with provided code and title', () => {
+            const error = new BaseRendererError({ code: 5, title: 'Test Error' });
+            
+            expect(error.code).toBe(5);
+            expect(error.title).toBe('Test Error');
+        });
+
+        it('should create instance with options parameter', () => {
+            const options = { isBreakdown: true, minCategories: 5 };
+            const error = new BaseRendererError({ code: 5, title: 'Test Error', options });
+            
+            expect(error.code).toBe(5);
+            expect(error.title).toBe('Test Error');
+            expect(error.options).toEqual(options);
+        });
+
+        it('should set empty options object when no options provided', () => {
+            const error = new BaseRendererError({ code: 1, title: 'Test' });
+            
+            expect(error.options).toEqual({});
+        });
+
+        it('should be instance of BaseRendererError', () => {
+            const error = new BaseRendererError({ code: 1, title: 'Test' });
+            expect(error).toBeInstanceOf(BaseRendererError);
+        });
+
+        it('should be instance of Error', () => {
+            const error = new BaseRendererError({ code: 1, title: 'Test' });
+            expect(error).toBeInstanceOf(Error);
+        });
+    });
+
+    describe('NoDataError', () => {
+        it('should create instance with correct code and title', () => {
+            const error = new NoDataError();
+            
+            expect(error.code).toBe(1);
+            expect(error.title).toBe('No Data Available');
+        });
+
+        it('should be instance of BaseRendererError', () => {
+            const error = new NoDataError();
+            expect(error).toBeInstanceOf(BaseRendererError);
+        });
+    });
+
+    describe('TooMuchDataError', () => {
+        it('should create instance with correct code and title', () => {
+            const error = new TooMuchDataError();
+            
+            expect(error.code).toBe(3);
+            expect(error.title).toBe('There is too much data. Please edit this widget');
+        });
+
+        it('should be instance of BaseRendererError', () => {
+            const error = new TooMuchDataError();
+            expect(error).toBeInstanceOf(BaseRendererError);
+        });
+    });
+
+    describe('DataConflictError', () => {
+        it('should create instance with correct code and title', () => {
+            const error = new DataConflictError();
+            
+            expect(error.code).toBe(5);
+            expect(error.title).toBe('Data Conflict');
+        });
+
+        it('should create instance with options parameter', () => {
+            const options = {
+                isBreakdown: true,
+                uniqueCategories: ['A', 'B'],
+                minCategories: 5,
+                maxCategories: 10
+            };
+            const error = new DataConflictError(options);
+            
+            expect(error.code).toBe(5);
+            expect(error.title).toBe('Data Conflict');
+            expect(error.options).toEqual(options);
+        });
+
+        it('should create instance with empty options when none provided', () => {
+            const error = new DataConflictError();
+            
+            expect(error.options).toEqual({});
+        });
+    });
+
+    describe('GaugeConfigurationError', () => {
+        it('should create instance with correct code and title', () => {
+            const error = new GaugeConfigurationError();
+            
+            expect(error.code).toBe(6);
+            expect(error.title).toBe('Please configure goal and needle');
+        });
+
+        it('should create instance with empty options', () => {
+            const error = new GaugeConfigurationError();
+            
+            expect(error.options).toEqual({});
+        });
+    });
+
+    describe('GenericRenderingError', () => {
+        it('should create instance with correct code and title', () => {
+            const error = new GenericRenderingError();
+            
+            expect(error.code).toBe(7);
+            expect(error.title).toBe('An error occurred rendering the PivotTable results.');
+        });
+
+        it('should create instance with empty options', () => {
+            const error = new GenericRenderingError();
+            
+            expect(error.options).toEqual({});
+        });
+
+        it('should be instance of BaseRendererError', () => {
+            const error = new GenericRenderingError();
+            expect(error).toBeInstanceOf(BaseRendererError);
+        });
+    });
+
+    describe('GenericComputationalError', () => {
+        it('should create instance with correct code and title', () => {
+            const error = new GenericComputationalError();
+            
+            expect(error.code).toBe(8);
+            expect(error.title).toBe('An error occurred computing the PivotTable results.');
+        });
+
+        it('should create instance with empty options', () => {
+            const error = new GenericComputationalError();
+            
+            expect(error.options).toEqual({});
+        });
+
+        it('should be instance of BaseRendererError', () => {
+            const error = new GenericComputationalError();
+            expect(error).toBeInstanceOf(BaseRendererError);
+        });
+    });
+});