@vizzly/dashboard 0.14.4-dev-f81c05d870985862e147c5e214f0dc91eb44478a → 0.14.4-dev-10397d77eda0887a2486552a23d06fbce1a8e6d0

package/dist/dashboard.esm.js

@@ -55,6 +55,7 @@ import { AxisBottom as AxisBottom$1, AxisLeft as AxisLeft$1 } from '@visx/axis';
 import { Text } from '@visx/text';
 import { GridRows as GridRows$1 } from '@visx/grid';
 import '@visx/point';
+import { RadarChart as RadarChart$4 } from './charts/src/v2/components/RadarChart';
 import VisibilitySensor from 'react-visibility-sensor';
 import ExcelJS from 'exceljs';
 import { saveAs } from 'file-saver';
@@ -8163,7 +8164,319 @@ var RichText = function RichText(config) {
   };
 };
 
-var componentTypes = ['areaChart', 'barChart', 'basicTable', 'bubbleChart', 'comboChart', 'custom', 'dataTable', 'funnelChart', 'horizontalBarChart', 'lineChart', 'lineChartV2', 'areaChartV2', 'barChartV2', 'mercatorMap', 'pieChart', 'progress', 'richText', 'scatterChart', 'singleStat', 'waterfallChart'];
+var attributesSchema$d = function attributesSchema(config) {
+  return Joi.object(_extends({}, baseAttributesSchema(config.attributesSchemaOptions), timeDimensionQuerySchema(config.queryEngineConfig, config.attributesSchemaOptions), {
+    legend: Joi.valid(true, false),
+    type: Joi.valid('radarChart').required(),
+    parameters: parametersSchema(config.queryEngineConfig, config.attributesSchemaOptions),
+    axisTitles: axisTitleSchema(),
+    headline: headlineSchema(),
+    tags: tagsSchema()
+  }));
+};
+
+var setAttributes$c = (function (config) {
+  return function (radarChart, partial) {
+    var newAttributes = setAttributes(radarChart, partial, attributesSchema$d(config));
+    newAttributes = removeUnusedOrderFieldsFromTimeSeriesComponent(newAttributes);
+    return newAttributes;
+  };
+});
+
+var CONSTANTS$e = {
+  title: 'Radar chart',
+  description: 'Visualizes multiple variables as points on axes starting from the same center point, creating a spider web-like shape. Perfect for comparing strengths and weaknesses across multiple dimensions or showing performance metrics across different categories.',
+  namespace: 'radar_chart',
+  data_panel: {
+    data_set: {
+      type: 'dataSet',
+      title: 'Data set',
+      description: 'What data do you want to use in this radar chart?'
+    },
+    views: {
+      type: 'views',
+      title: 'View',
+      description: ''
+    },
+    field_y_axis: {
+      type: 'fieldCollector',
+      title: 'Metric - Y Axis',
+      description: 'What do you want each line to measure?',
+      callToAction: 'Add metric'
+    },
+    field_x_axis: {
+      type: 'fieldCollector',
+      title: 'Grouping - X Axis',
+      description: 'What do you want each line to represent? An example might be a `product category` field to represent each category as a line.',
+      callToAction: 'Add grouping'
+    },
+    sort: {
+      type: 'sort',
+      title: 'Sort',
+      description: 'Select the order of categories or time on the x Axis.'
+    },
+    filter: {
+      type: 'filter',
+      title: 'Filters',
+      description: 'Only include the information you want to use in this radar chart.'
+    },
+    custom_metrics: {
+      type: 'customMetrics',
+      title: 'Custom metrics',
+      description: 'Build your own metrics, such as a percentage.'
+    },
+    limit: {
+      type: 'limit',
+      title: 'Limit',
+      description: 'Set the maximum number of records to show on this radar chart.'
+    }
+  },
+  format_panel: {
+    heading: {
+      type: 'heading',
+      title: 'Heading',
+      description: '',
+      subSectionDefinition: {
+        title: {
+          type: 'title',
+          title: 'Title',
+          description: '',
+          namespace: 'title'
+        },
+        subject: {
+          title: 'Subject',
+          type: 'subject',
+          description: '',
+          namespace: 'subject'
+        }
+      }
+    },
+    chart_styles: {
+      type: 'chartStyles',
+      title: 'Chart Settings',
+      description: '',
+      subSectionDefinition: {
+        curve: {
+          type: 'curve',
+          title: 'Line Style',
+          description: '',
+          namespace: 'curve'
+        },
+        //Idk what is this
+        legend: {
+          type: 'legend',
+          title: 'Show Legend',
+          description: '',
+          namespace: 'legend'
+        }
+      }
+    },
+    axis_labels: {
+      type: 'axisLabels',
+      title: 'Axis Preferences',
+      description: '',
+      subSectionDefinition: {
+        x: {
+          title: 'Grouping - X Axis',
+          description: '',
+          namespace: 'x'
+        },
+        'x.prefix': {
+          title: 'Prefix',
+          description: '',
+          namespace: 'x.prefix'
+        },
+        'x.postfix': {
+          title: 'Postfix',
+          description: '',
+          namespace: 'x.postfix'
+        },
+        'x.format': {
+          title: 'Format',
+          description: '',
+          namespace: 'x.format'
+        },
+        'x.count': {
+          title: 'Label count',
+          description: '',
+          namespace: 'x.count'
+        },
+        y: {
+          title: 'Metric - Y Axis',
+          description: '',
+          namespace: 'y'
+        },
+        'y.prefix': {
+          title: 'Prefix',
+          description: '',
+          namespace: 'y.prefix'
+        },
+        'y.postfix': {
+          title: 'Postfix',
+          description: '',
+          namespace: 'y.postfix'
+        },
+        'y.format': {
+          title: 'Format',
+          description: '',
+          namespace: 'y.format'
+        },
+        'y.count': {
+          title: 'Label count',
+          description: '',
+          namespace: 'y.count'
+        }
+      }
+    }
+  }
+};
+
+console.log(axisLabelsConstants(CONSTANTS$e));
+var RadarChart = function RadarChart(config) {
+  return {
+    title: CONSTANTS$e.title,
+    description: CONSTANTS$e.description,
+    servicesClass: 'RadarChart',
+    namespace: CONSTANTS$e.namespace,
+    dump: function dump(hydrated) {
+      return hydrated;
+    },
+    load: function load(dumped) {
+      var _dumped$tags;
+      return {
+        type: dumped.type,
+        measure: upcastMeasure(dumped.measure),
+        order: upcastOrder(dumped.order, dumped.timeDimension),
+        dimension: upcastStringDimensionsToObject(dumped.dimension),
+        // TODO: upcast dumped.timeDimension -> dimension
+        displayTitle: dumped.displayTitle,
+        displaySubject: dumped.displaySubject,
+        protectedByOrganisation: dumped.protectedByOrganisation,
+        viewId: upcastViewId(dumped.viewId),
+        filter: upcastFilter(dumped.filter),
+        dataSetId: dumped.dataSetId,
+        limit: dumped.limit,
+        timeDimension: null,
+        xAxisPostfix: dumped.xAxisPostfix,
+        xAxisPrefix: dumped.xAxisPrefix,
+        yAxisPostfix: dumped.yAxisPostfix,
+        yAxisPrefix: dumped.yAxisPrefix,
+        yAxisFormat: dumped.yAxisFormat,
+        xAxisFormat: dumped.xAxisFormat,
+        approxXAxisLabelCount: upcastAxisLabel(dumped.approxXAxisLabelCount),
+        approxYAxisLabelCount: upcastAxisLabel(dumped.approxYAxisLabelCount),
+        legend: dumped.legend,
+        tags: (_dumped$tags = dumped.tags) != null ? _dumped$tags : []
+      };
+    },
+    setAttributes: setAttributes$c(config),
+    validate: function validate(attrs, dataSets) {
+      return validateView(attrs, dataSets, config.queryEngineConfig);
+    },
+    init: function init(dataSetId, overrides) {
+      return _extends({
+        type: 'radarChart',
+        measure: [],
+        dimension: [],
+        timeDimension: null,
+        displayTitle: '',
+        displaySubject: '',
+        protectedByOrganisation: undefined,
+        viewId: upcastViewId(overrides == null ? void 0 : overrides.viewId),
+        filter: [],
+        order: [],
+        dataSetId: dataSetId,
+        limit: 5000,
+        xAxisPostfix: '',
+        xAxisPrefix: '',
+        yAxisPostfix: '',
+        yAxisPrefix: '',
+        yAxisFormat: null,
+        xAxisFormat: null,
+        legend: true,
+        approxXAxisLabelCount: 'auto',
+        approxYAxisLabelCount: 'auto',
+        parameters: {},
+        axisTitles: undefined,
+        headline: undefined,
+        tags: []
+      }, overrides);
+    },
+    createFeedback: createFeedback,
+    schema: attributesSchema$d(config),
+    removeField: function removeField(attrs, fieldId) {
+      return removeField$1(attrs, fieldId, config.queryEngineConfig);
+    },
+    isRunnable: function isRunnable(hydrated) {
+      return hydrated.measure.length > 0 && hydrated.dimension.length > 0;
+    },
+    autoGenerate: function autoGenerate(dataSet) {
+      var _DataSet$buildQueryAt = buildQueryAttributes(dataSet, config.queryEngineConfig, 'lineChart'),
+        measure = _DataSet$buildQueryAt.measure,
+        dimension = _DataSet$buildQueryAt.dimension;
+      return this.init(dataSet.id, {
+        measure: [measure[0]],
+        dimension: dimension
+      });
+    },
+    dataPanelConfig: function dataPanelConfig() {
+      return [namespace(CONSTANTS$e, 'data_set'), namespace(CONSTANTS$e, 'views'), _extends({}, namespace(CONSTANTS$e, 'field_y_axis'), {
+        fieldFilterOptions: {
+          forComponent: 'lineChart'
+        },
+        preSetPartialAttributes: function preSetPartialAttributes(values) {
+          return {
+            measure: values
+          };
+        },
+        getValues: function getValues(attrs) {
+          return attrs.measure;
+        },
+        testId: 'metric-input'
+      }), _extends({}, namespace(CONSTANTS$e, 'field_x_axis'), {
+        fieldFilterOptions: {
+          forComponent: 'lineChart',
+          onlyDimensions: true
+        },
+        preventDuplicates: false,
+        // return all values in the dimension array instead of seperating out timeDimension
+        preSetPartialAttributes: function preSetPartialAttributes(values) {
+          return {
+            dimension: [].concat(values)
+          };
+        },
+        // does this need to be updated too?
+        getValues: function getValues(attrs) {
+          return [].concat(attrs.dimension);
+        },
+        maxAllowed: 2,
+        testId: 'add-dimension'
+      }), namespace(CONSTANTS$e, 'sort'), namespace(CONSTANTS$e, 'filter'), namespace(CONSTANTS$e, 'custom_metrics'), namespace(CONSTANTS$e, 'limit')];
+    },
+    formatPanelConfig: function formatPanelConfig() {
+      return [headingConstant(CONSTANTS$e), chartStylesConstant(CONSTANTS$e, false, false), axisLabelsConstants(CONSTANTS$e)];
+    },
+    supportedCustomFields: {
+      calculatedField: false,
+      percentages: true,
+      dateCalculations: true,
+      simpleMaths: true,
+      rules: true,
+      aggregateMaths: true,
+      roundedNumbers: true,
+      conditional: true
+    },
+    supportedFeatures: {
+      parameters: true,
+      colorGradient: false
+    },
+    setDataAttributesFromPreAggregatedDataSet: function setDataAttributesFromPreAggregatedDataSet$1(attributes, dataSet) {
+      return setDataAttributesFromPreAggregatedDataSet(attributes, dataSet, this.setAttributes);
+    }
+  };
+};
+
+var componentTypes = ['areaChart', 'barChart', 'basicTable', 'bubbleChart', 'comboChart', 'custom', 'dataTable', 'funnelChart', 'horizontalBarChart', 'lineChart', 'lineChartV2', 'areaChartV2', 'barChartV2', 'mercatorMap', 'pieChart', 'progress', 'richText', 'scatterChart', 'singleStat', 'waterfallChart', 'radarChart'];
 /** @deprecated */
 
 var ProgressType = /*#__PURE__*/function (ProgressType) {
@@ -8172,7 +8485,7 @@ var ProgressType = /*#__PURE__*/function (ProgressType) {
   return ProgressType;
 }({});
 
-var attributesSchema$d = function attributesSchema(config) {
+var attributesSchema$e = function attributesSchema(config) {
   return Joi.object(_extends({}, baseAttributesSchema(config.attributesSchemaOptions), {
     measure: Joi.array().items(measureSchema(config.queryEngineConfig.supportedAggregates, config.attributesSchemaOptions)),
     filter: queryAttributesFilter(config.queryEngineConfig),
@@ -8195,7 +8508,7 @@ var attributesSchema$d = function attributesSchema(config) {
   }));
 };
 
-var CONSTANTS$e = {
+var CONSTANTS$f = {
   title: 'Progress',
   description: 'Used to show progress towards goals, completion of tasks, or as indicators of performance metrics.',
   namespace: 'progress',
@@ -8283,12 +8596,12 @@ var CONSTANTS$e = {
 
 var Progress = function Progress(config) {
   return {
-    title: CONSTANTS$e.title,
-    description: CONSTANTS$e.description,
+    title: CONSTANTS$f.title,
+    description: CONSTANTS$f.description,
     dump: function dump(hydrated) {
       return hydrated;
     },
-    namespace: CONSTANTS$e.namespace,
+    namespace: CONSTANTS$f.namespace,
     servicesClass: 'Progress',
     load: function load(dumped) {
       var _dumpedButUpcasted$ta;
@@ -8314,7 +8627,7 @@ var Progress = function Progress(config) {
       };
     },
     setAttributes: function setAttributes$1(hydrated, partial) {
-      return setAttributes(hydrated, partial, attributesSchema$d(config));
+      return setAttributes(hydrated, partial, attributesSchema$e(config));
     },
     validate: function validate(attrs, dataSets) {
       return validateView(attrs, dataSets, config.queryEngineConfig);
@@ -8340,7 +8653,7 @@ var Progress = function Progress(config) {
         tags: []
       }, overrides);
     },
-    schema: attributesSchema$d(config),
+    schema: attributesSchema$e(config),
     removeField: function removeField(attrs, fieldId) {
       return removeField$1(attrs, fieldId, config.queryEngineConfig);
     },
@@ -8351,14 +8664,14 @@ var Progress = function Progress(config) {
       return this.init(dataSet.id);
     },
     dataPanelConfig: function dataPanelConfig() {
-      return [namespace(CONSTANTS$e, 'data_set'), namespace(CONSTANTS$e, 'views'), namespace(CONSTANTS$e, 'progress_goals'), namespace(CONSTANTS$e, 'filter'), namespace(CONSTANTS$e, 'custom_metrics')];
+      return [namespace(CONSTANTS$f, 'data_set'), namespace(CONSTANTS$f, 'views'), namespace(CONSTANTS$f, 'progress_goals'), namespace(CONSTANTS$f, 'filter'), namespace(CONSTANTS$f, 'custom_metrics')];
     },
     formatPanelConfig: function formatPanelConfig() {
-      return [headingConstant(CONSTANTS$e), namespace(CONSTANTS$e, 'progress_type'), _extends({}, namespace(CONSTANTS$e, 'stats_labels'), {
-        prefix: statsLabelsConstant(CONSTANTS$e, 'prefix'),
-        postfix: statsLabelsConstant(CONSTANTS$e, 'postfix'),
-        format: statsLabelsConstant(CONSTANTS$e, 'format'),
-        count: statsLabelsConstant(CONSTANTS$e, 'count')
+      return [headingConstant(CONSTANTS$f), namespace(CONSTANTS$f, 'progress_type'), _extends({}, namespace(CONSTANTS$f, 'stats_labels'), {
+        prefix: statsLabelsConstant(CONSTANTS$f, 'prefix'),
+        postfix: statsLabelsConstant(CONSTANTS$f, 'postfix'),
+        format: statsLabelsConstant(CONSTANTS$f, 'format'),
+        count: statsLabelsConstant(CONSTANTS$f, 'count')
       })];
     },
     supportedCustomFields: {
@@ -8378,7 +8691,7 @@ var Progress = function Progress(config) {
   };
 };
 
-var setAttributes$c = (function (config) {
+var setAttributes$d = (function (config) {
   return function (lineChart, partial) {
     var newAttributes = setAttributes(lineChart, partial, attributesSchema(config));
     newAttributes = removeUnusedOrderFieldsFromTimeSeriesComponent(newAttributes);
@@ -8386,7 +8699,7 @@ var setAttributes$c = (function (config) {
   };
 });
 
-var CONSTANTS$f = {
+var CONSTANTS$g = {
   title: 'Funnel chart',
   description: 'Track conversion between stages of a process.',
   namespace: 'funnel_chart',
@@ -8554,10 +8867,10 @@ var CONSTANTS$f = {
 
 var FunnelChart = function FunnelChart(config) {
   return {
-    title: CONSTANTS$f.title,
-    description: CONSTANTS$f.description,
+    title: CONSTANTS$g.title,
+    description: CONSTANTS$g.description,
     servicesClass: 'FunnelChart',
-    namespace: CONSTANTS$f.namespace,
+    namespace: CONSTANTS$g.namespace,
     dump: function dump(hydrated) {
       return hydrated;
     },
@@ -8575,7 +8888,7 @@ var FunnelChart = function FunnelChart(config) {
         parameters: upcastParameters(dumped.parameters)
       });
     },
-    setAttributes: setAttributes$c(config),
+    setAttributes: setAttributes$d(config),
     validate: function validate(attrs, dataSets) {
       return validateView(attrs, dataSets, config.queryEngineConfig);
     },
@@ -8627,7 +8940,7 @@ var FunnelChart = function FunnelChart(config) {
       });
     },
     dataPanelConfig: function dataPanelConfig() {
-      return [namespace(CONSTANTS$f, 'data_set'), namespace(CONSTANTS$f, 'views'), _extends({}, namespace(CONSTANTS$f, 'field_y_axis'), {
+      return [namespace(CONSTANTS$g, 'data_set'), namespace(CONSTANTS$g, 'views'), _extends({}, namespace(CONSTANTS$g, 'field_y_axis'), {
         fieldFilterOptions: {
           forComponent: 'funnelChart'
         },
@@ -8642,7 +8955,7 @@ var FunnelChart = function FunnelChart(config) {
           return attrs.measure;
         },
         testId: 'metric-input'
-      }), _extends({}, namespace(CONSTANTS$f, 'field_x_axis'), {
+      }), _extends({}, namespace(CONSTANTS$g, 'field_x_axis'), {
         fieldFilterOptions: {
           forComponent: 'funnelChart',
           onlyDimensions: true
@@ -8657,12 +8970,12 @@ var FunnelChart = function FunnelChart(config) {
         },
         maxAllowed: 1,
         testId: 'add-dimension'
-      }), namespace(CONSTANTS$f, 'sort'), namespace(CONSTANTS$f, 'filter'), namespace(CONSTANTS$f, 'custom_metrics'), namespace(CONSTANTS$f, 'limit')];
+      }), namespace(CONSTANTS$g, 'sort'), namespace(CONSTANTS$g, 'filter'), namespace(CONSTANTS$g, 'custom_metrics'), namespace(CONSTANTS$g, 'limit')];
     },
     formatPanelConfig: function formatPanelConfig() {
-      return [headingConstant(CONSTANTS$f), chartStylesConstant(CONSTANTS$f, false, false), axisLabelsConstants(CONSTANTS$f), _extends({}, namespace(CONSTANTS$f, 'conditional_formatting'), {
+      return [headingConstant(CONSTANTS$g), chartStylesConstant(CONSTANTS$g, false, false), axisLabelsConstants(CONSTANTS$g), _extends({}, namespace(CONSTANTS$g, 'conditional_formatting'), {
         ruleType: 'backgroundColor'
-      }), namespace(CONSTANTS$f, 'headline')];
+      }), namespace(CONSTANTS$g, 'headline')];
     },
     supportedCustomFields: {
       percentages: true,
@@ -8930,7 +9243,7 @@ function isStatsLabels(panel) {
   return 'prefix' in panel;
 }
 
-var attributesSchema$e = function attributesSchema(config) {
+var attributesSchema$f = function attributesSchema(config) {
   return Joi.object(_extends({}, baseAttributesSchema(config.attributesSchemaOptions), {
     xMeasure: measureSchema(config.queryEngineConfig.supportedAggregates, config.attributesSchemaOptions).allow(null),
     yMeasure: measureSchema(config.queryEngineConfig.supportedAggregates, config.attributesSchemaOptions).allow(null),
@@ -8957,9 +9270,9 @@ var attributesSchema$e = function attributesSchema(config) {
   }));
 };
 
-var setAttributes$d = (function (config) {
+var setAttributes$e = (function (config) {
   return function (bubbleChart, partial) {
-    var newAttributes = setAttributes(bubbleChart, partial, attributesSchema$e(config));
+    var newAttributes = setAttributes(bubbleChart, partial, attributesSchema$f(config));
     var allowedOrderSpec = [];
     if (newAttributes.xMeasure) {
       allowedOrderSpec.push(newAttributes.xMeasure);
@@ -8983,7 +9296,7 @@ var setAttributes$d = (function (config) {
   };
 });
 
-var CONSTANTS$g = {
+var CONSTANTS$h = {
   title: 'Bubble chart',
   description: 'Displays data points on a Cartesian plane, with a third metric corresponding to bubble size.',
   namespace: 'bubble_chart',
@@ -9182,10 +9495,10 @@ var CONSTANTS$g = {
 
 var BubbleChart = function BubbleChart(config) {
   return {
-    title: CONSTANTS$g.title,
-    description: CONSTANTS$g.description,
+    title: CONSTANTS$h.title,
+    description: CONSTANTS$h.description,
     servicesClass: 'BubbleChart',
-    namespace: CONSTANTS$g.namespace,
+    namespace: CONSTANTS$h.namespace,
     dump: function dump(hydrated) {
       return hydrated;
     },
@@ -9220,7 +9533,7 @@ var BubbleChart = function BubbleChart(config) {
         tags: (_dumped$tags = dumped.tags) != null ? _dumped$tags : []
       };
     },
-    setAttributes: setAttributes$d(config),
+    setAttributes: setAttributes$e(config),
     validate: function validate(attrs, dataSets) {
       return validateView(attrs, dataSets, config.queryEngineConfig);
     },
@@ -9255,7 +9568,7 @@ var BubbleChart = function BubbleChart(config) {
       }, overrides);
     },
     createFeedback: createFeedback,
-    schema: attributesSchema$e(config),
+    schema: attributesSchema$f(config),
     removeField: function removeField(attrs, fieldId) {
       return removeField$1(attrs, fieldId, config.queryEngineConfig);
     },
@@ -9274,18 +9587,18 @@ var BubbleChart = function BubbleChart(config) {
     },
     dataPanelConfig: function dataPanelConfig() {
       var _CONSTANTS$data_panel, _CONSTANTS$data_panel2, _CONSTANTS$data_panel3;
-      return [namespace(CONSTANTS$g, 'data_set'), namespace(CONSTANTS$g, 'views'), _extends({}, namespace(CONSTANTS$g, 'labelled_metrics'), {
-        subSection: [_extends({}, (_CONSTANTS$data_panel = CONSTANTS$g.data_panel.labelled_metrics) == null ? void 0 : _CONSTANTS$data_panel.subSectionDefinition['xAxis'], {
+      return [namespace(CONSTANTS$h, 'data_set'), namespace(CONSTANTS$h, 'views'), _extends({}, namespace(CONSTANTS$h, 'labelled_metrics'), {
+        subSection: [_extends({}, (_CONSTANTS$data_panel = CONSTANTS$h.data_panel.labelled_metrics) == null ? void 0 : _CONSTANTS$data_panel.subSectionDefinition['xAxis'], {
           propKey: 'xMeasure',
           allowsMultiple: false
-        }), _extends({}, (_CONSTANTS$data_panel2 = CONSTANTS$g.data_panel.labelled_metrics) == null ? void 0 : _CONSTANTS$data_panel2.subSectionDefinition['yAxis'], {
+        }), _extends({}, (_CONSTANTS$data_panel2 = CONSTANTS$h.data_panel.labelled_metrics) == null ? void 0 : _CONSTANTS$data_panel2.subSectionDefinition['yAxis'], {
           propKey: 'yMeasure',
           allowsMultiple: false
-        }), _extends({}, (_CONSTANTS$data_panel3 = CONSTANTS$g.data_panel.labelled_metrics) == null ? void 0 : _CONSTANTS$data_panel3.subSectionDefinition['zAxis'], {
+        }), _extends({}, (_CONSTANTS$data_panel3 = CONSTANTS$h.data_panel.labelled_metrics) == null ? void 0 : _CONSTANTS$data_panel3.subSectionDefinition['zAxis'], {
           propKey: 'zMeasure',
           allowsMultiple: false
         })]
-      }), _extends({}, namespace(CONSTANTS$g, 'field_grouping'), {
+      }), _extends({}, namespace(CONSTANTS$h, 'field_grouping'), {
         fieldFilterOptions: {
           onlyDimensions: true,
           onlyFieldTypes: ['boolean', 'number', 'string'],
@@ -9303,13 +9616,13 @@ var BubbleChart = function BubbleChart(config) {
           return attrs.dimension;
         },
         testId: 'add-dimension'
-      }), namespace(CONSTANTS$g, 'filter'), namespace(CONSTANTS$g, 'custom_metrics'), namespace(CONSTANTS$g, 'limit')];
+      }), namespace(CONSTANTS$h, 'filter'), namespace(CONSTANTS$h, 'custom_metrics'), namespace(CONSTANTS$h, 'limit')];
     },
     formatPanelConfig: function formatPanelConfig() {
       var _CONSTANTS$format_pan;
-      return [headingConstant(CONSTANTS$g), _extends({}, namespace(CONSTANTS$g, 'chart_styles'), {
-        subSection: [(_CONSTANTS$format_pan = CONSTANTS$g.format_panel.chart_styles) == null ? void 0 : _CONSTANTS$format_pan.subSectionDefinition.legend]
-      }), axisLabelsConstants(CONSTANTS$g), namespace(CONSTANTS$g, 'goal_line')];
+      return [headingConstant(CONSTANTS$h), _extends({}, namespace(CONSTANTS$h, 'chart_styles'), {
+        subSection: [(_CONSTANTS$format_pan = CONSTANTS$h.format_panel.chart_styles) == null ? void 0 : _CONSTANTS$format_pan.subSectionDefinition.legend]
+      }), axisLabelsConstants(CONSTANTS$h), namespace(CONSTANTS$h, 'goal_line')];
     },
     supportedCustomFields: {
       percentages: true,
@@ -9328,7 +9641,7 @@ var BubbleChart = function BubbleChart(config) {
   };
 };
 
-var attributesSchema$f = function attributesSchema(config) {
+var attributesSchema$g = function attributesSchema(config) {
   return Joi.object(_extends({}, baseAttributesSchema(config.attributesSchemaOptions), timeDimensionQuerySchema(config.queryEngineConfig, config.attributesSchemaOptions), {
     stacked: Joi.valid(true, false),
     legend: Joi.valid(true, false),
@@ -9343,15 +9656,15 @@ var attributesSchema$f = function attributesSchema(config) {
   }));
 };
 
-var setAttributes$e = (function (config) {
+var setAttributes$f = (function (config) {
   return function (barChart, partial) {
-    var newAttributes = setAttributes(barChart, partial, attributesSchema$f(config));
+    var newAttributes = setAttributes(barChart, partial, attributesSchema$g(config));
     newAttributes = removeUnusedOrderFieldsFromTimeSeriesComponent(newAttributes);
     return newAttributes;
   };
 });
 
-var CONSTANTS$h = {
+var CONSTANTS$i = {
   title: 'Bar Chart V2',
   description: 'Ideal for illustrating changes and trends over time with bar graphs.',
   namespace: 'bar_chart',
@@ -9573,7 +9886,7 @@ var BarChart$1 = function BarChart(config) {
         drilldownOptions: dumped.drilldownOptions
       };
     },
-    setAttributes: setAttributes$e(config),
+    setAttributes: setAttributes$f(config),
     validate: function validate(attrs, dataSets) {
       return validateView(attrs, dataSets, config.queryEngineConfig);
     },
@@ -9611,7 +9924,7 @@ var BarChart$1 = function BarChart(config) {
       }, overrides);
     },
     createFeedback: createFeedback,
-    schema: attributesSchema$f(config),
+    schema: attributesSchema$g(config),
     removeField: function removeField(attrs, fieldId) {
       return removeField$1(attrs, fieldId, config.queryEngineConfig);
     },
@@ -9628,7 +9941,7 @@ var BarChart$1 = function BarChart(config) {
       });
     },
     dataPanelConfig: function dataPanelConfig() {
-      return [namespace(CONSTANTS$h, 'data_set'), namespace(CONSTANTS$h, 'views'), _extends({}, namespace(CONSTANTS$h, 'field_y_axis'), {
+      return [namespace(CONSTANTS$i, 'data_set'), namespace(CONSTANTS$i, 'views'), _extends({}, namespace(CONSTANTS$i, 'field_y_axis'), {
         fieldFilterOptions: {
           forComponent: 'barChart'
         },
@@ -9641,7 +9954,7 @@ var BarChart$1 = function BarChart(config) {
           return attrs.measure;
         },
         testId: 'metric-input'
-      }), _extends({}, namespace(CONSTANTS$h, 'field_x_axis'), {
+      }), _extends({}, namespace(CONSTANTS$i, 'field_x_axis'), {
         fieldFilterOptions: {
           forComponent: 'barChart',
           onlyDimensions: true
@@ -9659,16 +9972,16 @@ var BarChart$1 = function BarChart(config) {
         },
         maxAllowed: 2,
         testId: 'add-dimension'
-      }), namespace(CONSTANTS$h, 'sort'), namespace(CONSTANTS$h, 'filter'), _extends({}, namespace(CONSTANTS$h, 'drilldown'), {
+      }), namespace(CONSTANTS$i, 'sort'), namespace(CONSTANTS$i, 'filter'), _extends({}, namespace(CONSTANTS$i, 'drilldown'), {
         options: {
           property: 'drilldownOptions'
         }
-      }), namespace(CONSTANTS$h, 'custom_metrics'), namespace(CONSTANTS$h, 'limit')];
+      }), namespace(CONSTANTS$i, 'custom_metrics'), namespace(CONSTANTS$i, 'limit')];
     },
     formatPanelConfig: function formatPanelConfig() {
-      return [headingConstant(CONSTANTS$h), chartStylesConstant(CONSTANTS$h, false, true), axisLabelsConstants(CONSTANTS$h), _extends({}, namespace(CONSTANTS$h, 'conditional_formatting'), {
+      return [headingConstant(CONSTANTS$i), chartStylesConstant(CONSTANTS$i, false, true), axisLabelsConstants(CONSTANTS$i), _extends({}, namespace(CONSTANTS$i, 'conditional_formatting'), {
         ruleType: 'lineColor'
-      }), namespace(CONSTANTS$h, 'goal_line')];
+      }), namespace(CONSTANTS$i, 'goal_line')];
     },
     supportedCustomFields: {
       calculatedField: false,
@@ -9690,7 +10003,7 @@ var BarChart$1 = function BarChart(config) {
   };
 };
 
-var attributesSchema$g = function attributesSchema(config) {
+var attributesSchema$h = function attributesSchema(config) {
   return Joi.object(_extends({}, baseAttributesSchema(config.attributesSchemaOptions), timeDimensionQuerySchema(config.queryEngineConfig, config.attributesSchemaOptions), {
     legend: Joi.valid(true, false),
     type: Joi.valid('waterfallChart').required(),
@@ -9701,15 +10014,15 @@ var attributesSchema$g = function attributesSchema(config) {
   }));
 };
 
-var setAttributes$f = (function (config) {
+var setAttributes$g = (function (config) {
   return function (waterfallChart, partial) {
-    var newAttributes = setAttributes(waterfallChart, partial, attributesSchema$g(config));
+    var newAttributes = setAttributes(waterfallChart, partial, attributesSchema$h(config));
     newAttributes = removeUnusedOrderFieldsFromTimeSeriesComponent(newAttributes);
     return newAttributes;
   };
 });
 
-var CONSTANTS$i = {
+var CONSTANTS$j = {
   title: 'Waterfall chart',
   description: "Shows a running total as values are added or subtracted. It's useful for understanding how an initial value is affected by a series of positive and negative values.",
   namespace: 'waterfall_chart',
@@ -9867,10 +10180,10 @@ var CONSTANTS$i = {
 
 var WaterfallChart = function WaterfallChart(config) {
   return {
-    title: CONSTANTS$i.title,
-    description: CONSTANTS$i.description,
+    title: CONSTANTS$j.title,
+    description: CONSTANTS$j.description,
     servicesClass: 'WaterfallChart',
-    namespace: CONSTANTS$i.namespace,
+    namespace: CONSTANTS$j.namespace,
     dump: function dump(hydrated) {
       return hydrated;
     },
@@ -9905,7 +10218,7 @@ var WaterfallChart = function WaterfallChart(config) {
         offset: dumped.offset
       };
     },
-    setAttributes: setAttributes$f(config),
+    setAttributes: setAttributes$g(config),
     validate: function validate(attrs, dataSets) {
       return validateView(attrs, dataSets, config.queryEngineConfig);
     },
@@ -9940,7 +10253,7 @@ var WaterfallChart = function WaterfallChart(config) {
       }, overrides);
     },
     createFeedback: createFeedback,
-    schema: attributesSchema$g(config),
+    schema: attributesSchema$h(config),
     removeField: function removeField(attrs, fieldId) {
       return removeField$1(attrs, fieldId, config.queryEngineConfig);
     },
@@ -9957,7 +10270,7 @@ var WaterfallChart = function WaterfallChart(config) {
       });
     },
     dataPanelConfig: function dataPanelConfig() {
-      return [namespace(CONSTANTS$i, 'data_set'), namespace(CONSTANTS$i, 'views'), _extends({}, namespace(CONSTANTS$i, 'field_y_axis'), {
+      return [namespace(CONSTANTS$j, 'data_set'), namespace(CONSTANTS$j, 'views'), _extends({}, namespace(CONSTANTS$j, 'field_y_axis'), {
         fieldFilterOptions: {
           forComponent: 'waterfallChart',
           onlyMeasures: true
@@ -9971,7 +10284,7 @@ var WaterfallChart = function WaterfallChart(config) {
           return attrs.measure;
         },
         testId: 'metric-input'
-      }), _extends({}, namespace(CONSTANTS$i, 'field_x_axis'), {
+      }), _extends({}, namespace(CONSTANTS$j, 'field_x_axis'), {
         fieldFilterOptions: {
           forComponent: 'waterfallChart',
           onlyDimensions: true
@@ -9985,10 +10298,10 @@ var WaterfallChart = function WaterfallChart(config) {
         },
         maxAllowed: 2,
         testId: 'add-dimension'
-      }), namespace(CONSTANTS$i, 'sort'), namespace(CONSTANTS$i, 'filter'), namespace(CONSTANTS$i, 'custom_metrics'), namespace(CONSTANTS$i, 'limit')];
+      }), namespace(CONSTANTS$j, 'sort'), namespace(CONSTANTS$j, 'filter'), namespace(CONSTANTS$j, 'custom_metrics'), namespace(CONSTANTS$j, 'limit')];
     },
     formatPanelConfig: function formatPanelConfig() {
-      return [headingConstant(CONSTANTS$i), chartStylesConstant(CONSTANTS$i, false, false), axisLabelsConstants(CONSTANTS$i)];
+      return [headingConstant(CONSTANTS$j), chartStylesConstant(CONSTANTS$j, false, false), axisLabelsConstants(CONSTANTS$j)];
     },
     supportedCustomFields: {
       percentages: true,
@@ -10010,7 +10323,7 @@ var WaterfallChart = function WaterfallChart(config) {
   };
 };
 
-var attributesSchema$h = function attributesSchema(config) {
+var attributesSchema$i = function attributesSchema(config) {
   return Joi.object(_extends({}, baseAttributesSchema(config.attributesSchemaOptions), timeDimensionQuerySchema(config.queryEngineConfig, config.attributesSchemaOptions), {
     stacked: Joi.valid(true, false),
     legend: Joi.valid(true, false),
@@ -10026,15 +10339,15 @@ var attributesSchema$h = function attributesSchema(config) {
   }));
 };
 
-var setAttributes$g = (function (config) {
+var setAttributes$h = (function (config) {
   return function (lineChart, partial) {
-    var newAttributes = setAttributes(lineChart, partial, attributesSchema$h(config));
+    var newAttributes = setAttributes(lineChart, partial, attributesSchema$i(config));
     newAttributes = removeUnusedOrderFieldsFromTimeSeriesComponent(newAttributes);
     return newAttributes;
   };
 });
 
-var CONSTANTS$j = {
+var CONSTANTS$k = {
   title: 'Area chart',
   description: 'Ideal for illustrating changes and trends over time with area graphs.',
   namespace: 'area_chart',
@@ -10268,7 +10581,7 @@ var AreaChart$1 = function AreaChart(config) {
         stacked: dumped.stacked
       };
     },
-    setAttributes: setAttributes$g(config),
+    setAttributes: setAttributes$h(config),
     validate: function validate(attrs, dataSets) {
       return validateView(attrs, dataSets, config.queryEngineConfig);
     },
@@ -10308,7 +10621,7 @@ var AreaChart$1 = function AreaChart(config) {
       }, overrides);
     },
     createFeedback: createFeedback,
-    schema: attributesSchema$h(config),
+    schema: attributesSchema$i(config),
     removeField: function removeField(attrs, fieldId) {
       return removeField$1(attrs, fieldId, config.queryEngineConfig);
     },
@@ -10325,7 +10638,7 @@ var AreaChart$1 = function AreaChart(config) {
       });
     },
     dataPanelConfig: function dataPanelConfig() {
-      return [namespace(CONSTANTS$j, 'data_set'), namespace(CONSTANTS$j, 'views'), _extends({}, namespace(CONSTANTS$j, 'field_y_axis'), {
+      return [namespace(CONSTANTS$k, 'data_set'), namespace(CONSTANTS$k, 'views'), _extends({}, namespace(CONSTANTS$k, 'field_y_axis'), {
         fieldFilterOptions: {
           forComponent: 'lineChart'
         },
@@ -10338,7 +10651,7 @@ var AreaChart$1 = function AreaChart(config) {
           return attrs.measure;
         },
         testId: 'metric-input'
-      }), _extends({}, namespace(CONSTANTS$j, 'field_x_axis'), {
+      }), _extends({}, namespace(CONSTANTS$k, 'field_x_axis'), {
         fieldFilterOptions: {
           forComponent: 'lineChart',
           onlyDimensions: true
@@ -10356,12 +10669,12 @@ var AreaChart$1 = function AreaChart(config) {
         },
         maxAllowed: 2,
         testId: 'add-dimension'
-      }), namespace(CONSTANTS$j, 'sort'), namespace(CONSTANTS$j, 'filter'), namespace(CONSTANTS$j, 'custom_metrics'), namespace(CONSTANTS$j, 'limit')];
+      }), namespace(CONSTANTS$k, 'sort'), namespace(CONSTANTS$k, 'filter'), namespace(CONSTANTS$k, 'custom_metrics'), namespace(CONSTANTS$k, 'limit')];
     },
     formatPanelConfig: function formatPanelConfig() {
-      return [headingConstant(CONSTANTS$j), chartStylesConstant(CONSTANTS$j, true, false), axisLabelsConstants(CONSTANTS$j), _extends({}, namespace(CONSTANTS$j, 'conditional_formatting'), {
+      return [headingConstant(CONSTANTS$k), chartStylesConstant(CONSTANTS$k, true, false), axisLabelsConstants(CONSTANTS$k), _extends({}, namespace(CONSTANTS$k, 'conditional_formatting'), {
         ruleType: 'lineColor'
-      }), namespace(CONSTANTS$j, 'goal_line')];
+      }), namespace(CONSTANTS$k, 'goal_line')];
     },
     supportedCustomFields: {
       calculatedField: false,
@@ -10416,6 +10729,7 @@ function getComponentInterface(type, config) {
   if (type == 'scatterChart') return textOverrideComponent(ScatterChart(config || EMPTY_CONFIG), config == null ? void 0 : config.textOverride);
   if (type == 'singleStat') return textOverrideComponent(SingleStat(config || EMPTY_CONFIG), config == null ? void 0 : config.textOverride);
   if (type == 'waterfallChart') return textOverrideComponent(WaterfallChart(config || EMPTY_CONFIG), config == null ? void 0 : config.textOverride);
+  if (type == 'radarChart') return textOverrideComponent(RadarChart(config || EMPTY_CONFIG), config == null ? void 0 : config.textOverride);
   throw "Cannot get interface for " + type + ". Please implement it.";
 }
 
@@ -13566,7 +13880,7 @@ var buildDefaults = function buildDefaults(partialFeatureToggles) {
   };
 };
 
-var ALL_COMPONENT_TYPES = ['barChart', 'bubbleChart', 'horizontalBarChart', 'funnelChart', 'areaChart', 'areaChartV2', 'lineChart', 'lineChartV2', 'barChartV2', 'scatterChart', 'pieChart', 'singleStat', 'dataTable', 'basicTable', 'comboChart', 'mercatorMap', 'progress', 'richText', 'custom', 'waterfallChart'];
+var ALL_COMPONENT_TYPES = ['barChart', 'bubbleChart', 'horizontalBarChart', 'funnelChart', 'areaChart', 'areaChartV2', 'lineChart', 'lineChartV2', 'barChartV2', 'scatterChart', 'pieChart', 'singleStat', 'dataTable', 'basicTable', 'comboChart', 'mercatorMap', 'progress', 'richText', 'custom', 'waterfallChart', 'radarChart'];
 var ALL_VIZZLY_COMPONENT_TYPES = /*#__PURE__*/[].concat(ALL_COMPONENT_TYPES).filter(function (type) {
   return type != 'custom';
 });
@@ -13906,7 +14220,7 @@ var saveable = function saveable(component, protectedComponent) {
   };
 };
 
-var attributesSchema$i = function attributesSchema(config) {
+var attributesSchema$j = function attributesSchema(config) {
   return Joi.alternatives().conditional('.type', {
     is: 'barChart',
     then: BarChart(config).schema
@@ -13967,6 +14281,9 @@ var attributesSchema$i = function attributesSchema(config) {
   }).conditional('.type', {
     is: 'waterfallChart',
     then: WaterfallChart(config).schema
+  }).conditional('.type', {
+    is: 'radarChart',
+    then: RadarChart(config).schema
   });
 };
 
@@ -21309,7 +21626,7 @@ var Combobox = function Combobox(props) {
   });
 };
 
-var attributesSchema$j = /*#__PURE__*/Joi.object({
+var attributesSchema$k = /*#__PURE__*/Joi.object({
   displayTitle: /*#__PURE__*/Joi.string().min(1).required(),
   colSpan: /*#__PURE__*/Joi.number().valid(12).required()
 });
@@ -21326,7 +21643,7 @@ var isEmptyCell = /*#__PURE__*/Joi.object({
 });
 var isPopulatedCell = function isPopulatedCell(queryEngineConfig) {
   return Joi.object({
-    attributes: attributesSchema$i({
+    attributes: attributesSchema$j({
       queryEngineConfig: queryEngineConfig
     }),
     colSpan: colSpanSchema
@@ -21337,7 +21654,7 @@ var saveableDashboardDefinitionSchema = function saveableDashboardDefinitionSche
     id: Joi.string(),
     display: displaySchema(queryEngineConfig),
     componentLibrary: Joi.array().required().items(Joi.object({
-      attributes: attributesSchema$i({
+      attributes: attributesSchema$j({
         queryEngineConfig: queryEngineConfig
       })
     })),
@@ -21348,7 +21665,7 @@ var saveableDashboardDefinitionSchema = function saveableDashboardDefinitionSche
 function displaySchema(queryEngineConfig) {
   return Joi.array().required().items(Joi.object({
     height: Joi.number().required(),
-    components: Joi.array().required().min(1).items(Joi.alternatives(isEmptyCell, isPopulatedCell(queryEngineConfig), attributesSchema$j))
+    components: Joi.array().required().min(1).items(Joi.alternatives(isEmptyCell, isPopulatedCell(queryEngineConfig), attributesSchema$k))
   }));
 }
 
@@ -22070,7 +22387,7 @@ var setHeaderComponent = function setHeaderComponent(state, action) {
   newDisplayState.dashboard.display[rowIndex].components[cellIndex] = component;
   return newDisplayState;
 };
-var setAttributes$h = function setAttributes(state, action) {
+var setAttributes$i = function setAttributes(state, action) {
   var attributes = action.attributes,
     rowIndex = action.rowIndex,
     cellIndex = action.cellIndex;
@@ -22355,7 +22672,7 @@ var reducer = function reducer(pipelineTransformationOptions) {
         case 'swapComponents':
           return swapComponents$1(state, action);
         case 'setAttributes':
-          return setAttributes$h(state, action);
+          return setAttributes$i(state, action);
         case 'addComponentToLibrary':
           return addComponentToLibrary(state, action);
         case 'setLocalFilters':
@@ -25924,6 +26241,19 @@ var ComboChart$1 = function ComboChart(props) {
     })
   }));
 };
+var RadarChart$1 = function RadarChart(props) {
+  return jsx("svg", _extends({}, props, {
+    viewBox: "0 0 24 24",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: jsx("path", {
+      d: "M12 3L16.4498 6.51028L21 9.87539M12 3L7.55015 6.51028L3 9.87539M12 3V7.97508M21 9.87539L19.2 15.41L17.5623 21M21 9.87539L16.5 11.4128M17.5623 21L12 20.9103L6.43769 21M17.5623 21L14.7812 16.9751M6.43769 21L4.8 15.41L3 9.87539M6.43769 21L8.5 18M3 9.87539L7.5 11.4128M12 12.9502L8.5 18M12 12.9502L14.7812 16.9751M12 12.9502L16.5 11.4128M12 12.9502V7.97508M12 12.9502L7.5 11.4128M8.5 18L14.7812 16.9751M8.5 18L7.5 11.4128M14.7812 16.9751L16.5 11.4128M16.5 11.4128L12 7.97508M12 7.97508L7.5 11.4128",
+      stroke: "#5C6770",
+      "stroke-width": "1.5",
+      "stroke-linejoin": "round"
+    })
+  }));
+};
 var MercatorMap$1 = function MercatorMap(props) {
   return jsx("svg", _extends({
     xmlns: "http://www.w3.org/2000/svg",
@@ -26025,6 +26355,9 @@ var componentTypeToIconMapping = {
   waterfallChart: function waterfallChart(color) {
     return WaterfallChart$1(color);
   },
+  radarChart: function radarChart(color) {
+    return RadarChart$1(color);
+  },
   custom: function custom(_p) {
     return jsx(Fragment$1, {});
   }
@@ -49834,6 +50167,511 @@ var AreaChartV2 = function AreaChartV2(props) {
   });
 };
 
+var getMinAndMax = function getMinAndMax(_ref) {
+  var data = _ref.data,
+    keys = _ref.keys,
+    dataType = _ref.dataType;
+  if (keys.length === 0) return {
+    max: null,
+    min: null
+  };
+  if (dataType === 'date_time') {
+    var dataToAnalyse = [].concat(data.flatMap(function (dataItem) {
+      return keys.map(function (key) {
+        return dataItem[key] ? new Date(dataItem[key].value).valueOf() : 0;
+      });
+    }));
+    return {
+      max: Math.max.apply(Math, dataToAnalyse),
+      min: Math.min.apply(Math, dataToAnalyse)
+    };
+  } else if (dataType === 'number') {
+    var _dataToAnalyse = [].concat(data.flatMap(function (dataItem) {
+      return keys.map(function (key) {
+        return dataItem[key] ? dataItem[key].value : 0;
+      });
+    }));
+    return {
+      max: Math.max.apply(Math, _dataToAnalyse),
+      min: Math.min.apply(Math, _dataToAnalyse)
+    };
+  }
+  return {
+    max: null,
+    min: null
+  };
+};
+
+function getNiceInterval$2(interval) {
+  // Round the interval to a "nice" value (1, 2, 5, etc.)
+  var exponent = Math.floor(Math.log10(interval));
+  var fraction = interval / Math.pow(10, exponent);
+  var niceFraction;
+  if (fraction <= 1.5) niceFraction = 1;else if (fraction <= 3) niceFraction = 2;else if (fraction <= 7) niceFraction = 5;else niceFraction = 10;
+  return niceFraction * Math.pow(10, exponent);
+}
+var getScaleAndTicks$1 = function getScaleAndTicks(_ref) {
+  var data = _ref.data,
+    xKey = _ref.xKey,
+    yKeys = _ref.yKeys,
+    xScaleDataType = _ref.xScaleDataType,
+    nullValue = _ref.nullValue,
+    tickCountYAxis = _ref.tickCountYAxis,
+    formattingFunctionX = _ref.formattingFunctionX,
+    formattingFunctionY = _ref.formattingFunctionY;
+  var xTicks = [];
+  var yTicks = [];
+  var xScale = {
+    dataType: xScaleDataType,
+    key: xKey
+  };
+  var x = getMinAndMax({
+    data: data,
+    keys: xScale.key === null ? [] : [xScale.key],
+    dataType: xScale.dataType
+  });
+  if (xKey) {
+    xTicks = data.map(function (dataItem) {
+      var _dataItem$xKey, _dataItem$xScale$key, _dataItem$xScale$key2;
+      var xValue = (_dataItem$xKey = dataItem[xKey]) != null && _dataItem$xKey.value ? dataItem[xKey].value : null;
+      var xformattedValue = formattingFunctionX(xValue, nullValue);
+      var xScaleValue = xScale.key !== null && (_dataItem$xScale$key = dataItem[xScale.key]) != null && _dataItem$xScale$key.value ? (_dataItem$xScale$key2 = dataItem[xScale.key]) == null ? void 0 : _dataItem$xScale$key2.value : '';
+      var xScaleValueAdjusted = xScale.dataType === 'date_time' ? new Date(xScaleValue) : xScale.dataType === 'string' ? String(xScaleValue) : xScale.dataType === 'number' ? Number(xScaleValue) : xScaleValue;
+      return {
+        value: xValue !== null ? xValue : '',
+        formattedValue: xformattedValue !== null ? "" + xformattedValue : null,
+        scaleValue: xScaleValueAdjusted
+      };
+    });
+  }
+  // ----- Y Axis ("number") -----
+
+  var y = getMinAndMax({
+    data: data,
+    keys: yKeys,
+    dataType: 'number'
+  });
+  var maxY = y.max || 0;
+  var minY = Math.min(y.min || 0, 0);
+  var yTickInterval = getNiceInterval$2((maxY - minY) / (tickCountYAxis - 1));
+  for (var i = 0; i <= tickCountYAxis; i++) {
+    var _value = yTickInterval * i;
+    var formattedValue = formattingFunctionY(_value, nullValue);
+    yTicks.push({
+      value: _value,
+      formattedValue: formattedValue,
+      scaleValue: _value
+    });
+  }
+  return {
+    x: {
+      ticks: xTicks,
+      scale: {
+        dataType: xScale.dataType,
+        max: x.max,
+        min: x.min,
+        key: xScale.key
+      }
+    },
+    y: {
+      ticks: yTicks,
+      scale: {
+        dataType: 'number',
+        key: null,
+        ordering: 'asc',
+        max: maxY,
+        min: minY
+      }
+    }
+  };
+};
+
+var buildRadarChartRepresentation = function buildRadarChartRepresentation(_ref) {
+  var _xKeys$;
+  var result = _ref.result,
+    xAxisFormat = _ref.xAxisFormat,
+    xAxisPostfix = _ref.xAxisPostfix,
+    xAxisPrefix = _ref.xAxisPrefix,
+    yAxisFormat = _ref.yAxisFormat,
+    yAxisPostfix = _ref.yAxisPostfix,
+    yAxisPrefix = _ref.yAxisPrefix,
+    colors = _ref.colors,
+    dateTimeFormatOptions = _ref.dateTimeFormatOptions,
+    defaultFormats = _ref.defaultFormats,
+    nullValue = _ref.nullValue,
+    numberFormatOptions = _ref.numberFormatOptions,
+    pivotConfig = _ref.pivotConfig,
+    _valueAlias = _ref.valueAlias,
+    approxYAxisLabelCount = _ref.approxYAxisLabelCount,
+    seriesLabelFormatter = _ref.seriesLabelFormatter;
+  var activeDateTimeFormats = {};
+  var _buildFieldFormatMaps = buildFieldFormatMaps(result, pivotConfig, xAxisPrefix, xAxisPostfix, xAxisFormat, yAxisPrefix, yAxisPostfix, yAxisFormat, nullValue, numberFormatOptions),
+    allPrefixes = _buildFieldFormatMaps.allPrefixes,
+    allPostfixes = _buildFieldFormatMaps.allPostfixes,
+    nullValues = _buildFieldFormatMaps.nullValues,
+    activeNumberFormats = _buildFieldFormatMaps.activeNumberFormats;
+  var params = {
+    defaultFormats: defaultFormats,
+    dateTimeFormatOptions: dateTimeFormatOptions,
+    numberFormatOptions: numberFormatOptions,
+    valueAlias: function valueAlias(params) {
+      if (typeof _valueAlias === 'function') {
+        return String(_valueAlias({
+          fieldId: id({
+            field: params.fieldId,
+            "function": params["function"]
+          }),
+          value: params.value
+        }));
+      }
+      return undefined;
+    },
+    nullValue: nullValues,
+    prefixes: allPrefixes,
+    postfixes: allPostfixes,
+    activeNumberFormats: activeNumberFormats,
+    activeDateTimeFormats: activeDateTimeFormats
+  };
+  var formattedResult = formatResult(result, params);
+  var xKeyField = getXKeyField(pivotConfig, result.fields);
+  var formattingFunctionX = function formattingFunctionX(value) {
+    if (!xKeyField) return '';
+    return formattedResult.formatterFunc(value, {
+      fieldId: xKeyField.fieldId,
+      "function": xKeyField["function"],
+      outputDataType: xKeyField.outputDataType
+    }).formattedValue;
+  };
+  var formattingFunctionY = function formattingFunctionY(value) {
+    var nonPivotField = formattedResult.fields.find(function (resultField) {
+      return ![].concat(pivotConfig.x, pivotConfig.y).includes(resultField.id);
+    });
+    if (!nonPivotField) return '';
+    return formattedResult.formatterFunc(value, {
+      fieldId: nonPivotField.fieldId,
+      "function": nonPivotField["function"],
+      outputDataType: nonPivotField.outputDataType
+    }).formattedValue;
+  };
+  var xScaleDataType = (xKeyField == null ? void 0 : xKeyField.outputDataType) || 'string';
+  var _formattedResultToSer = formattedResultToSeries(formattedResult, pivotConfig, seriesLabelFormatter),
+    keys = _formattedResultToSer.keys,
+    yKeys = _formattedResultToSer.yKeys,
+    xKeys = _formattedResultToSer.xKeys,
+    chartData = _formattedResultToSer.seriesData;
+  var xKey = (_xKeys$ = xKeys[0]) != null ? _xKeys$ : null;
+  var ticks = getScaleAndTicks$1({
+    data: chartData,
+    xKey: xKey,
+    xScaleDataType: xScaleDataType,
+    yKeys: yKeys,
+    tickCountYAxis: approxYAxisLabelCount,
+    formattingFunctionX: formattingFunctionX,
+    formattingFunctionY: formattingFunctionY,
+    nullValue: nullValue
+  });
+  var styleDefinition = getStyleDefinition({
+    colors: colors,
+    yKeys: yKeys,
+    style: {
+      strokeWidth: 3,
+      strokeDasharray: null,
+      type: 'line'
+    }
+  });
+  var chart = {
+    keys: keys,
+    x: {
+      ticks: ticks.x.ticks,
+      scale: {
+        dataType: ticks.x.scale.dataType,
+        key: ticks.x.scale.key,
+        min: ticks.x.scale.min,
+        max: ticks.x.scale.max,
+        ordering: 'asc'
+      },
+      key: xKey,
+      postfix: xAxisPostfix,
+      prefix: xAxisPrefix,
+      title: null
+    },
+    y: {
+      ticks: ticks.y.ticks,
+      scale: {
+        dataType: ticks.y.scale.dataType,
+        key: ticks.y.scale.key,
+        min: ticks.y.scale.min,
+        max: ticks.y.scale.max,
+        ordering: 'asc'
+      },
+      keys: yKeys,
+      postfix: yAxisPostfix,
+      prefix: yAxisPrefix,
+      title: null
+    },
+    data: chartData,
+    lines: styleDefinition
+  };
+  return chart;
+};
+
+var ASSUMED_AVERAGE_CHAR_WIDTH$2 = 8.8;
+var MIN_RADIUS_SPACING = 60;
+function adjustRadialTicksForOverlap(ticks, maxHeight, avgCharWidth) {
+  if (avgCharWidth === void 0) {
+    avgCharWidth = ASSUMED_AVERAGE_CHAR_WIDTH$2;
+  }
+  var radius = maxHeight / 2;
+  var maxTicks = Math.ceil(radius / MIN_RADIUS_SPACING);
+  if (ticks.length <= maxTicks) {
+    return ticks;
+  }
+  var ticksToKeep = Math.min(maxTicks, Math.ceil(radius / (avgCharWidth * Math.max.apply(Math, ticks.map(function (tick) {
+    return tick.formattedValue ? tick.formattedValue.toString().length : 0;
+  })))));
+  return pickEquallySpaced$2(ticks, ticksToKeep).map(function (tick) {
+    return _extends({}, tick, {
+      value: Number(tick.value),
+      scaleValue: typeof tick.scaleValue === 'number' ? tick.scaleValue : null
+    });
+  });
+}
+function pickEquallySpaced$2(arr, numPicks) {
+  if (numPicks >= arr.length) {
+    return arr;
+  }
+  var result = [];
+  var interval = (arr.length - 1) / (numPicks - 1);
+  for (var i = 0; i < numPicks; i++) {
+    var index = Math.round(i * interval);
+    result.push(arr[index]);
+  }
+  return result;
+}
+var adjustTicks$2 = function adjustTicks(chartRepresentation, width) {
+  chartRepresentation = cloneDeep(chartRepresentation);
+  var minDimension = width;
+  chartRepresentation.y.ticks = adjustRadialTicksForOverlap(chartRepresentation.y.ticks, minDimension, ASSUMED_AVERAGE_CHAR_WIDTH$2);
+  return chartRepresentation;
+};
+
+var RadarChartView = function RadarChartView(props) {
+  var _theme$charts$colors, _theme$charts;
+  var approxYAxisLabelCount = props.approxYAxisLabelCount,
+    approxXAxisLabelCount = props.approxXAxisLabelCount,
+    dataSet = props.dataSet,
+    dataSetId = props.dataSetId,
+    dimension = props.dimension,
+    displaySubject = props.displaySubject,
+    displayTitle = props.displayTitle,
+    headline = props.headline,
+    id = props.id,
+    legend = props.legend,
+    library = props.library,
+    localFilters = props.localFilters,
+    measure = props.measure,
+    order = props.order,
+    parameters = props.parameters,
+    protectedByOrganisation = props.protectedByOrganisation,
+    queriesAreChanging = props.queriesAreChanging,
+    result = props.result,
+    setLocalFilters = props.setLocalFilters,
+    setPartialAttributes = props.setPartialAttributes,
+    timeDimension = props.timeDimension,
+    type = props.type,
+    viewId = props.viewId,
+    xAxisFormat = props.xAxisFormat,
+    xAxisPostfix = props.xAxisPostfix,
+    xAxisPrefix = props.xAxisPrefix,
+    yAxisFormat = props.yAxisFormat,
+    yAxisPostfix = props.yAxisPostfix,
+    yAxisPrefix = props.yAxisPrefix,
+    defaultFormats = props.defaultFormats;
+  var _useDashboardBehaviou = useDashboardBehaviourContext(),
+    textOverride = _useDashboardBehaviou.textOverride,
+    valueAlias = _useDashboardBehaviou.valueAlias,
+    developerTools = _useDashboardBehaviou.developerTools,
+    numberFormatOptions = _useDashboardBehaviou.numberFormatOptions,
+    dateTimeFormatOptions = _useDashboardBehaviou.dateTimeFormatOptions,
+    queryEngineConfig = _useDashboardBehaviou.queryEngineConfig,
+    labelFormat = _useDashboardBehaviou.labelFormat;
+  var theme = useTheme();
+  var headerProps = {
+    displayTitle: displayTitle,
+    displaySubject: displaySubject,
+    localFilters: localFilters,
+    setLocalFilters: setLocalFilters,
+    setPartialAttributes: setPartialAttributes,
+    library: library != null ? library : false,
+    verified: protectedByOrganisation,
+    dataSet: dataSet,
+    parameters: parameters,
+    componentType: type,
+    measure: measure,
+    dimension: dimension,
+    timeDimension: timeDimension,
+    viewId: viewId != null ? viewId : '',
+    order: order
+  };
+  useDeveloperTools({
+    developerTools: developerTools,
+    viewId: id
+  });
+  var RadarChartComponent = getComponentInterface(type);
+  if (!RadarChartComponent.isRunnable(props)) return jsx(QueryUnderConstructionNotice, {
+    title: "Missing parameters"
+  });
+  if (isLoading(result)) return jsx(LoadingComponent, {});
+  if (hasFailed(result)) return jsx(FailedToLoadDataNotice, {});
+  if (isEmpty(result)) return jsx(NoResultContentToShowNotice, _extends({}, headerProps));
+  var showHeadline = headlineAvailable(order, headline, timeDimension);
+  var pivotConfig = init$c(props);
+  var chartRepresentation = buildRadarChartRepresentation({
+    result: result,
+    xAxisFormat: xAxisFormat,
+    xAxisPrefix: xAxisPrefix,
+    xAxisPostfix: xAxisPostfix,
+    yAxisFormat: yAxisFormat,
+    yAxisPrefix: yAxisPrefix,
+    yAxisPostfix: yAxisPostfix,
+    colors: (_theme$charts$colors = theme == null || (_theme$charts = theme.charts) == null ? void 0 : _theme$charts.colors) != null ? _theme$charts$colors : DEFAULT_CHART_COLORS,
+    dateTimeFormatOptions: dateTimeFormatOptions,
+    defaultFormats: defaultFormats,
+    nullValue: checkForNullValue(dataSetId, dimension, timeDimension, textOverride, valueAlias),
+    numberFormatOptions: numberFormatOptions,
+    pivotConfig: pivotConfig,
+    valueAlias: valueAlias,
+    approxYAxisLabelCount: approxYAxisLabelCount === 'auto' ? 10 : approxYAxisLabelCount,
+    seriesLabelFormatter: function seriesLabelFormatter(labelFormatParams) {
+      var _queryEngineConfig$su, _queryEngineConfig$su2, _queryEngineConfig$su3;
+      var yResultField = labelFormatParams.yResultField,
+        yPivotFields = labelFormatParams.yPivotFields,
+        row = labelFormatParams.row;
+      var formattedFunctionName = ((_queryEngineConfig$su = queryEngineConfig.supportedAggregates[yResultField["function"]]) == null ? void 0 : _queryEngineConfig$su.publicName) || ((_queryEngineConfig$su2 = queryEngineConfig.supportedTimeTruncFunctions[yResultField["function"]]) == null ? void 0 : _queryEngineConfig$su2.publicName) || ((_queryEngineConfig$su3 = queryEngineConfig.supportedTransformationFunctions[yResultField["function"]]) == null ? void 0 : _queryEngineConfig$su3.publicName);
+      var formattedFunction = yResultField["function"] === 'none' ? '' : " \u2022 " + formattedFunctionName;
+      var defaultLabelFormat = "" + yPivotFields.map(function (field) {
+        return row[field.id].formattedValue;
+      }).join(' • ') + (yPivotFields.length === 0 ? '' : ' • ') + yResultField.publicName + formattedFunction;
+      if (!labelFormat) return defaultLabelFormat;
+      return labelFormat({
+        viewId: props.viewId,
+        fieldId: yResultField.fieldId,
+        func: yResultField["function"],
+        type: 'radarChart',
+        defaultLabel: defaultLabelFormat
+      }) || defaultLabelFormat;
+    }
+  });
+  var style = buildStyleOverrides({
+    display: 'flex',
+    width: '100%',
+    height: '100%',
+    flexDirection: 'column',
+    variants: {
+      overflowScroll: {
+        "false": {},
+        "true": _extends({
+          overflow: 'auto'
+        }, scrollBarStyles)
+      },
+      justifyCenter: {
+        "false": {},
+        "true": {
+          display: 'flex',
+          justifyContent: 'center'
+        }
+      }
+    }
+  });
+  return jsx(Suspense, {
+    fallback: jsx(LoadingComponent, {}),
+    children: jsxs(ViewWrapper, {
+      id: id,
+      queriesAreChanging: queriesAreChanging,
+      children: [jsx(ViewHeader, _extends({}, headerProps, {
+        paddingBottom: showHeadline ? '0.5rem' : undefined
+      })), showHeadline && jsx(HeadlineStats, _extends({}, props)), jsx("div", {
+        className: styles({
+          flex: '1',
+          position: 'relative'
+        }),
+        "aria-disabled": props.library,
+        children: jsx(ParentSize, {
+          className: "" + style({
+            overflowScroll: true,
+            justifyCenter: true
+          }),
+          children: function children(parent) {
+            if (chartRepresentation.data.length === 0) return jsx(LoadingComponent, {});
+            return jsx(RadarChart$4, {
+              width: parent.width,
+              height: parent.height,
+              options: {
+                showLegend: showLegend(legend, (theme == null ? void 0 : theme.detail) === 'verbose'),
+                showRoundedTotal: false,
+                removeStroke: false,
+                axis: {
+                  showYAxisLabels: approxYAxisLabelCount !== 0,
+                  showXAxisLabels: approxXAxisLabelCount !== 0
+                }
+              },
+              theme: theme == null ? void 0 : theme.charts,
+              chart: adjustTicks$2(chartRepresentation, parent.width)
+            });
+          }
+        })
+      })]
+    })
+  });
+};
+var RadarChartView$1 = /*#__PURE__*/memo(RadarChartView, shouldUpdate);
+
+var RadarChart$2 = function RadarChart(_ref) {
+  var component = _ref.component,
+    dataSet = _ref.dataSet,
+    dashboardBehaviour = _ref.dashboardBehaviour,
+    globalFilters = _ref.globalFilters,
+    id = _ref.id,
+    library = _ref.library,
+    runQueriesCallback = _ref.runQueriesCallback,
+    setLocalFilters = _ref.setLocalFilters,
+    _setPartialAttributes = _ref.setPartialAttributes,
+    setResults = _ref.setResults,
+    updateComponentAttributes = _ref.updateComponentAttributes;
+  var localFilters = component.localFilters,
+    results = component.results;
+  var _useState = useState(component.attributes),
+    attributes = _useState[0],
+    setAttributes = _useState[1];
+  var _useComponentEffect = useComponentEffect(component.attributes, dataSet, dashboardBehaviour.queryEngineConfig, {
+      localFilters: localFilters,
+      globalFilters: globalFilters
+    }, updateComponentAttributes, runQueriesCallback, setResults, dashboardBehaviour.variables),
+    queriesAreChanging = _useComponentEffect.queriesAreChanging;
+  useEffect(function () {
+    if (!queriesAreChanging) {
+      setAttributes(component.attributes);
+    }
+  }, [component.attributes, queriesAreChanging]);
+  return jsx(RadarChartView$1, _extends({
+    id: id
+  }, attributes, {
+    dataSet: dataSet,
+    localFilters: component.localFilters,
+    setLocalFilters: setLocalFilters,
+    setPartialAttributes: function setPartialAttributes(changes) {
+      return _setPartialAttributes(changes);
+    },
+    result: results && results[0],
+    queriesAreChanging: queriesAreChanging,
+    supportedAggregates: dashboardBehaviour.queryEngineConfig.supportedAggregates,
+    supportedTimeTruncFunctions: dashboardBehaviour.queryEngineConfig.supportedTimeTruncFunctions,
+    supportedTransformationFunctions: dashboardBehaviour.queryEngineConfig.supportedTransformationFunctions,
+    library: library,
+    defaultFormats: dashboardBehaviour.defaultFormats
+  }));
+};
+
 var Component = function Component(props) {
   var _useDashboardContext = useDashboardContext(),
     dashboard = _useDashboardContext.dashboard;
@@ -50325,6 +51163,32 @@ var Component = function Component(props) {
       })
     });
   }
+  if (props.component.attributes.type === 'radarChart') {
+    return jsx(ErrorBoundary, {
+      renderOnError: function renderOnError(onManualRetry) {
+        return jsx(ComponentErrorNotice, {
+          onManualRetry: onManualRetry
+        });
+      },
+      onError: dashboardBehaviour.onError,
+      children: jsx(RadarChart$2, {
+        id: props.id,
+        dataSet: dataSet,
+        setLocalFilters: props.setLocalFilters,
+        runQueriesCallback: props.runQueriesCallback,
+        updateComponentAttributes: function updateComponentAttributes(newAttributes) {
+          return _updateComponentAttributes(newAttributes);
+        },
+        component: props.component,
+        setResults: props.setResults,
+        globalFilters: dashboard.globalFilters,
+        dashboardBehaviour: dashboardBehaviour,
+        library: props == null ? void 0 : props.library,
+        idPrefix: idPrefix,
+        setPartialAttributes: setPartialAttributes
+      })
+    });
+  }
   if (props.component.attributes.type == 'waterfallChart') {
     return jsx(ErrorBoundary, {
       renderOnError: function renderOnError(onManualRetry) {
@@ -58502,7 +59366,7 @@ var ChartSettingsSection = function ChartSettingsSection(_ref) {
 };
 
 var AxisPreferenceSection = function AxisPreferenceSection(props) {
-  var _props$attributes, _props$attributes2, _props$attributes3, _props$attributes4, _props$section, _props$section2, _props$section$y, _props$section$y$form, _props$section$y$axis, _props$section$y$axis2, _props$attributes$axi, _props$section$x$form, _props$section$x, _props$section$x$axis, _props$section$x$axis2, _props$attributes$axi2;
+  var _props$attributes, _props$attributes2, _props$attributes3, _props$attributes4, _props$section, _props$section2, _props$section$y, _props$section$y$form, _props$section$y$axis, _props$attributes$axi, _props$section$x$form, _props$section$x, _props$section$x$axis, _props$attributes$axi2;
   var _useDashboardBehaviou = useDashboardBehaviourContext(),
     textOverride = _useDashboardBehaviou.textOverride,
     dateTimeFormatOptions = _useDashboardBehaviou.dateTimeFormatOptions;
@@ -58590,8 +59454,8 @@ var AxisPreferenceSection = function AxisPreferenceSection(props) {
             options: axisOptions
           })]
         }), jsx(Section.Grid, {
-          children: jsx(TextInput, {
-            label: (_props$section$y$axis = (_props$section$y$axis2 = props.section[y].axisTitle) == null ? void 0 : _props$section$y$axis2.title) != null ? _props$section$y$axis : '',
+          children: props.section[y].axisTitle && jsx(TextInput, {
+            label: (_props$section$y$axis = props.section[y].axisTitle.title) != null ? _props$section$y$axis : '',
             setText: function setText(axisTitle) {
               var _axisTitles;
               return props.setAttributes({
@@ -58674,8 +59538,8 @@ var AxisPreferenceSection = function AxisPreferenceSection(props) {
             })]
           })
         }), jsx(Section.Grid, {
-          children: jsx(TextInput, {
-            label: (_props$section$x$axis = (_props$section$x$axis2 = props.section[x].axisTitle) == null ? void 0 : _props$section$x$axis2.title) != null ? _props$section$x$axis : '',
+          children: props.section[x].axisTitle && jsx(TextInput, {
+            label: (_props$section$x$axis = props.section[x].axisTitle.title) != null ? _props$section$x$axis : '',
             setText: function setText(axisTitle) {
               var _axisTitles2;
               return props.setAttributes({
@@ -66668,6 +67532,18 @@ var WaterfallChart$4 = /*#__PURE__*/function (_View16) {
   };
   return WaterfallChart;
 }(View$3);
+var RadarChart$3 = /*#__PURE__*/function (_View17) {
+  function RadarChart(attributes) {
+    return _View17.call(this, _extends({}, attributes, {
+      type: 'radarChart'
+    })) || this;
+  }
+  _inheritsLoose(RadarChart, _View17);
+  RadarChart.type = function type() {
+    return 'radarChart';
+  };
+  return RadarChart;
+}(View$3);
 
 var VizzlyInstanceNotLoaded = /*#__PURE__*/function (_Error) {
   function VizzlyInstanceNotLoaded(instanceId) {
@@ -67006,6 +67882,8 @@ var toQueries$i = commonToQueries;
 
 var toQueries$j = commonToQueries;
 
+var toQueries$k = commonToQueries;
+
 var buildVizzlyViewQueries = function buildVizzlyViewQueries(attributes, dataSet, queryEngineConfig, params) {
   switch (attributes.type) {
     case 'areaChart':
@@ -67046,6 +67924,8 @@ var buildVizzlyViewQueries = function buildVizzlyViewQueries(attributes, dataSet
       return toQueries$i(attributes, dataSet, queryEngineConfig, params);
     case 'waterfallChart':
       return toQueries$j(attributes, dataSet, queryEngineConfig, params);
+    case 'radarChart':
+      return toQueries$k(attributes, dataSet, queryEngineConfig, params);
     default:
       throw 'Unsupported view when building query.';
   }
@@ -68595,6 +69475,7 @@ VizzlyServices.Header = Header;
 VizzlyServices.Library = Library$1;
 VizzlyServices.AreaChart = AreaChart$6;
 VizzlyServices.LineChart = LineChart$6;
+VizzlyServices.RadarChart = RadarChart$3;
 VizzlyServices.BarChart = BarChart$6;
 VizzlyServices.PieChart = PieChart$4;
 VizzlyServices.ScatterChart = ScatterChart$4;
@@ -69920,6 +70801,7 @@ var attributesToAiView = function attributesToAiView(dataSet, originalAttributes
   if (attributes.type === 'barChartV2') throw 'Bar Chart V2 views are not supported by Vizzly AI.';
   if (attributes.type === 'areaChartV2') throw 'Area Chart V2 views are not supported by Vizzly AI.';
   if (attributes.type === 'waterfallChart') throw 'Waterfall chart views are not supported by Vizzly AI.';
+  if (attributes.type === 'radarChart') throw 'Radar chart views are not supported by Vizzly AI.';
   var select = [];
   var group = [];
   var order = [];