@datarailsshared/dr_renderer 1.4.67 → 1.4.80

package/src/index.js

@@ -4,6 +4,7 @@ const initPivotTable = require('./pivottable');
 const initDRPivotTable = require('./dr_pivottable');
 const initNovixRenderer = require('./novix_renderer');
 const DataFormatter = require('./dataformatter');
+const errors = require('./errors');
 
 let dr_render_factory = {};
 
@@ -26,5 +27,15 @@ dr_render_factory.getInitPublishedItemsRenderer = function (publishedItemsRender
 
 dr_render_factory.DataFormatter = DataFormatter;
 
+// Export error types and classes
+dr_render_factory.RendererErrorCodes = errors.RendererErrorCodes;
+dr_render_factory.BaseRendererError = errors.BaseRendererError;
+dr_render_factory.TooMuchDataError = errors.TooMuchDataError;
+dr_render_factory.NoDataError = errors.NoDataError;
+dr_render_factory.DataConflictError = errors.DataConflictError;
+dr_render_factory.GaugeConfigurationError = errors.GaugeConfigurationError;
+dr_render_factory.GenericRenderingError = errors.GenericRenderingError;
+dr_render_factory.GenericComputationalError = errors.GenericComputationalError;
+
 //const $ = require( "jquery" )( window );
 module.exports = dr_render_factory;

package/src/pivot.css

@@ -5,17 +5,6 @@
   flex-direction: column;
 }
 
-.pivot-wrapper .noData--table-many-rows {
-    display: flex;
-    flex-direction: column;
-}
-.pivot-wrapper .noData--table-many-rows > *:first-child {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    line-height: 25px;
-}
-
 table.pvtTable {
     font-size: 8pt;
     text-align: left;

package/src/pivottable.js

@@ -1,4 +1,5 @@
 const helpers = require('./dr-renderer-helpers');
+const { GenericRenderingError, GenericComputationalError} = require('./errors');
 
 // from pivottable@2.23.0
 let initPivotTable = function($, window, document) {
@@ -9,7 +10,7 @@ let initPivotTable = function($, window, document) {
     /*
     Utilities
      */
-    var PivotData, addSeparators, aggregatorTemplates, aggregators, dayNamesEn, derivers, getSort, locales, mthNamesEn, naturalSort, numberFormat, pivotTableRenderer, rd, renderers, rx, rz, sortAs, usFmt, usFmtInt, usFmtPct, zeroPad, errorHandling;
+    var PivotData, addSeparators, aggregatorTemplates, aggregators, dayNamesEn, derivers, getSort, locales, mthNamesEn, naturalSort, numberFormat, pivotTableRenderer, rd, renderers, rx, rz, sortAs, usFmt, usFmtInt, usFmtPct, zeroPad;
     addSeparators = function(nStr, thousandsSep, decimalSep) {
         var rgx, x, x1, x2;
         nStr += '';
@@ -434,9 +435,6 @@ let initPivotTable = function($, window, document) {
             aggregators: aggregators,
             renderers: renderers,
             localeStrings: {
-                renderError: "An error occurred rendering the PivotTable results.",
-                computeError: "An error occurred computing the PivotTable results.",
-                uiRenderError: "An error occurred rendering the PivotTable UI.",
                 selectAll: "Select All",
                 selectNone: "Select None",
                 tooMany: "(too many to list)",
@@ -614,47 +612,6 @@ let initPivotTable = function($, window, document) {
         }
         return naturalSort;
     };
-    errorHandling = {
-        placeholders: {
-            nodata: {
-                title: 'No Data Available',
-                text: 'This might happen because of a global filter or a change in the underlying data',
-                btnText: '',
-                class: 'nodata',
-            },
-            noPermission: {
-                title: 'No Permission',
-                text: 'You do not have permission to view the data',
-                btnText: 'Request Permission',
-                class: 'no-permission',
-            },
-            tooMuchData: {
-                title: 'There is too much data. Please edit this widget',
-                text: '',
-                btnText: 'Edit Widget',
-                class: 'too-much-data',
-            },
-            noPublishItem: {
-                title: 'We can’t find the published item in the source file',
-                text: '',
-                btnText: 'Go to filebox',
-                class: 'no-publish-item',
-            },
-        },
-        getErrorPlaceholder: function(placeholder) {
-            if (placeholder && typeof placeholder === 'object') {
-                return $(`
-                    <div class="noData">
-                        <div class="noData-title">${placeholder.title}</div>
-                        <i class="noData-image ${placeholder.class}"></i>
-                        <div class="noData-text">${placeholder.text}</div>
-                        <div class="noData-error-action"></div>
-                    </div>
-                `);
-            }
-            return null;
-        },
-    };
 
     /*
     Data Model class
@@ -964,7 +921,6 @@ let initPivotTable = function($, window, document) {
         numberFormat: numberFormat,
         sortAs: sortAs,
         PivotData: PivotData,
-        errorHandling: errorHandling,
     };
     if (window.$) {
         window.$.pivotUtilities = $.pivotUtilities
@@ -1229,24 +1185,23 @@ let initPivotTable = function($, window, document) {
             localeStrings: localeStrings
         };
         opts = $.extend(true, {}, localeDefaults, $.extend({}, defaults, inputOpts));
-        result = null;
         try {
             pivotData = new opts.dataClass(input, opts);
             try {
                 result = opts.renderer(pivotData, opts.rendererOptions);
             } catch (error) {
-                e = error;
-                if (typeof console !== "undefined" && console !== null) {
-                    console.error(e.stack);
-                }
-                result = $("<span>").html(opts.localeStrings.renderError);
+                const genericRenderingError = new GenericRenderingError();
+                console.error(genericRenderingError.title);
+                throw genericRenderingError;
             }
         } catch (error) {
-            e = error;
-            if (typeof console !== "undefined" && console !== null) {
-                console.error(e.stack);
+            if (error instanceof GenericRenderingError) {
+                throw error;
+            } else {
+                const genericComputationalError = new GenericComputationalError();
+                console.error(genericComputationalError.title);
+                throw genericComputationalError;
             }
-            result = $("<span>").html(opts.localeStrings.computeError);
         }
         x = this[0];
         while (x.hasChildNodes()) {
@@ -1748,7 +1703,9 @@ let initPivotTable = function($, window, document) {
             if (typeof console !== "undefined" && console !== null) {
                 console.error(e.stack);
             }
-            this.html(opts.localeStrings.uiRenderError);
+            // This function is not used internally or in webclient_angular/export_widget_service
+            // TODO if it not removed in DR-39041, upgrade the error propagation
+            this.html("An error occurred rendering the PivotTable UI.");
         }
         return this;
     };

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

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

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);
+        });
+    });
+});