@trebco/treb 28.10.5 → 28.11.1

package/treb-export/src/drawing2/chart2.ts

@@ -27,6 +27,7 @@ import { static_title, ref_title, chart_template } from './chart-template-compon
 import { column_json, column_series } from './column-chart-template2';
 import { donut_json } from './donut-chart-template2';
 import { scatter_json, scatter_series } from './scatter-chart-template2';
+import { bubble_json, bubble_series } from './bubble-chart-template';
 
 import { XMLUtils } from '../xml-utils';
 
@@ -44,11 +45,12 @@ import { Localization } from 'treb-base-types';
 import type { RelationshipMap } from '../relationship';
 
 export interface ChartOptions {
-  type: 'donut'|'column'|'bar'|'scatter'|'scatter2';
+  type: 'donut'|'column'|'bar'|'scatter'|'scatter2' | 'bubble';
   title?: UnitLiteral | UnitAddress;
   data: UnitRange[];
   labels?: UnitRange;
   labels2?: UnitRange[];
+  labels3?: UnitRange[];
   names?: ExpressionUnit[];
   smooth?: boolean;
 }
@@ -110,6 +112,9 @@ export class Chart {
       case 'scatter2':
         return this.CreateScatterChart();
 
+      case 'bubble':
+        return this.CreateBubbleChart();
+        
       case 'donut':
         return this.CreateDonutChart();
 
@@ -121,6 +126,84 @@ export class Chart {
 
   }
 
+  public CreateBubbleChart() {
+
+    const template = JSON.parse(JSON.stringify(chart_template)); 
+    const chartspace = template['c:chartSpace'];
+    const bubble = JSON.parse(JSON.stringify(bubble_json)); 
+
+    chartspace['c:chart'] = bubble;
+
+    this.UpdateChartTitle(chartspace['c:chart']);
+
+    const cser = chartspace['c:chart']['c:plotArea']['c:bubbleChart']['c:ser']; // this.FindNode('c:ser', template);
+
+    let legend = false;
+
+    for (let i = 0; i < this.options.data.length; i++) {
+
+      const series = JSON.parse(JSON.stringify(bubble_series));
+
+      series['c:idx'] = { a$: { val: i.toString() }};
+      series['c:order'] = { a$: { val: i.toString() }};
+
+      if (this.options.names && this.options.names[i]) {
+
+        const name = this.options.names[i];
+        switch (name.type) {
+          case 'literal':
+            series['c:tx'] = {
+              'c:v': name.value.toString(),
+            };
+            legend = true;
+            break;
+
+          case 'range':
+          case 'address':
+            series['c:tx'] = {
+              'c:strRef': {
+                'c:f': name.label,
+              }
+            };
+            legend = true;
+            break;
+        }
+      }
+
+      // "accent7" will break 
+
+      if (i < 6) {
+        series['c:spPr']['a:solidFill']['a:schemeClr'].a$['val'] = `accent${i+1}`;
+      }
+
+      series['c:yVal']['c:numRef']['c:f'] = this.options.data[i]?.label;
+
+      if (this.options.labels2 && this.options.labels2[i]) {
+        series['c:xVal']['c:numRef']['c:f'] = this.options.labels2[i]?.label;
+      }
+
+      if (this.options.labels3 && this.options.labels3[i]) {
+        series['c:bubbleSize']['c:numRef']['c:f'] = this.options.labels3[i]?.label;
+      }
+
+      // console.info("SER", JSON.stringify(series, undefined, 2));
+
+      cser.push(series);
+
+    }
+
+    if (legend) {
+      chartspace['c:chart']['c:legend'] = {
+        'c:legendPos': { a$: {val: 'b'}, },
+        'c:overlay': { a$: {val: '0'}, },
+      };
+    }
+
+    return template;
+
+  }
+
+
   public CreateScatterChart() {
     
     const template = JSON.parse(JSON.stringify(chart_template)); 

package/treb-export/src/export2.ts

@@ -714,6 +714,9 @@ export class Exporter {
   /** overload for return type */
   public NormalizeAddress(unit: UnitRange, sheet: SerializedSheet): UnitRange;
 
+  /** extra overload */
+  public NormalizeAddress<UNIT = UnitAddress|UnitRange>(unit: UNIT, sheet: SerializedSheet): UNIT;
+
   /**
    * for charts we need addresses to be absolute ($)  and ensure there's
    * a sheet name -- use the active sheet if it's not explicitly referenced
@@ -738,6 +741,19 @@ export class Exporter {
 
   }
 
+  public EnsureRange(unit: UnitAddress|UnitRange): UnitRange {
+    if (unit.type === 'range') {
+      return unit;
+    }
+    return {
+      type: 'range',
+      start: unit,
+      end: unit,
+      label: unit.label,
+      id: unit.id,
+      position: unit.position,
+    };
+  }
 
   /** 
    * new-style annotation layout (kind of a two-cell anchor) to two-cell anchor
@@ -909,10 +925,13 @@ export class Exporter {
         }
         else if (/series/i.test(arg.name)) {
 
-          const [label, x, y] = arg.args; // y is required
+          const [label, x, y, z] = arg.args; // y is required
           
-          if (y && y.type === 'range') {
-            options.data.push(this.NormalizeAddress(y, sheet_source));
+          // FIXME: could be address also [x, y]
+
+          if (y && (y.type === 'range' || y.type === 'address')) {
+
+            options.data.push(this.EnsureRange(this.NormalizeAddress(y, sheet_source)));
 
             if (label) {
 
@@ -933,9 +952,16 @@ export class Exporter {
             }
 
             if (!options.labels2) { options.labels2 = []; }
-            if (x && x.type === 'range') {
-              options.labels2[options.data.length - 1] = this.NormalizeAddress(x, sheet_source);
+
+            if (x && (x.type === 'range' || x.type === 'address')) {
+              options.labels2[options.data.length - 1] = this.EnsureRange(this.NormalizeAddress(x, sheet_source));
+            }
+
+            if (z && (z.type === 'range' || z.type === 'address')) {
+              if (!options.labels3) { options.labels3 = []; }
+              options.labels3[options.data.length - 1] = this.EnsureRange(this.NormalizeAddress(z, sheet_source));
             }
+            
           }
           else {
             console.info('invalid series missing Y', {y, arg, ref});
@@ -951,30 +977,39 @@ export class Exporter {
       const parse_result = this.parser.Parse(annotation.formula || '');
       if (parse_result.expression && parse_result.expression.type === 'call') {
         
-        let type = '';
+        let type = ''; // FIXME
+
         switch (parse_result.expression.name.toLowerCase()) {
           case 'line.chart':
             type = 'scatter';
             break;
+
+          case 'bubble.chart':
+            type = 'bubble';
+            break;
+
           case 'scatter.line':
             type = 'scatter2';
             break;
+
           case 'donut.chart':
             type = 'donut';
             break;
+
           case 'bar.chart':
             type = 'bar';
             break;
+
           case 'column.chart':
             type = 'column';
             break;
         }
 
-        if (type === 'column' || type === 'donut' || type === 'bar' || type === 'scatter' || type === 'scatter2') {
+        if (type === 'column' || type === 'donut' || type === 'bar' || type === 'scatter' || type === 'scatter2' || type === 'bubble') {
 
           const options: ChartOptions = { type, data: [] };
 
-          const title_index = (type === 'scatter2') ? 1 : 2;
+          const title_index = (type === 'scatter2' || type === 'bubble') ? 1 : 2;
           const title_arg = parse_result.expression.args[title_index];
 
           if (title_arg && title_arg.type === 'literal') {
@@ -1000,7 +1035,7 @@ export class Exporter {
 
           if (parse_result.expression.args[0]) {
             const arg0 = parse_result.expression.args[0];
-            if (type === 'scatter2' || type === 'bar' || type === 'column' || type === 'scatter') {
+            if (type === 'scatter2' || type === 'bar' || type === 'column' || type === 'scatter' || type === 'bubble') {
               parse_series(arg0, options, sheet_source.name);
             }
             else if (arg0.type === 'range') {
@@ -1045,7 +1080,7 @@ export class Exporter {
             */
           }
 
-          if (type !== 'scatter2') {
+          if (type !== 'scatter2' && type !== 'bubble') {
             if (parse_result.expression.args[1] && parse_result.expression.args[1].type === 'range') {
               options.labels = this.NormalizeAddress(parse_result.expression.args[1], sheet_source);
             }
@@ -1064,6 +1099,10 @@ export class Exporter {
               options.smooth = true;
             }
           }
+          else if (type === 'bubble') {
+            // ...
+            // console.info({parse_result});
+          }
 
           // FIXME: fix this type (this happened when we switched from annotation
           // class to a data interface)

package/treb-export/src/import2.ts

@@ -917,6 +917,27 @@ export class Importer {
         const series = descriptor.chart?.series;
 
         switch(descriptor.chart.type) {
+
+          case ChartType.Bubble:
+            type = 'treb-chart';
+            func = 'Bubble.Chart';
+
+            if (series && series.length) {
+              args[0] = `Group(${series.map(s => `Series(${
+                [
+                  s.title || '',
+                  s.values || '',
+                  s.categories || '',
+                  s.bubble_size || '',
+
+                ].join(', ')
+              })`).join(', ')})`;
+            }
+           
+            args[1] = descriptor.chart.title;
+
+            break;
+
           case ChartType.Scatter:
             type = 'treb-chart';
             func = 'Scatter.Line';

package/treb-export/src/workbook2.ts

@@ -69,12 +69,13 @@ export const ConditionalFormatOperators: Record<string, string> = {
 };
 
 export enum ChartType {
-  Unknown = 0, Column, Bar, Line, Scatter, Donut, Pie
+  Unknown = 0, Column, Bar, Line, Scatter, Donut, Pie, Bubble
 }
 
 export interface ChartSeries {
   values?: string;
   categories?: string;
+  bubble_size?: string;
   title?: string;
 }
 
@@ -411,7 +412,7 @@ export class Workbook {
 
     }
 
-    const ParseSeries = (node: any, scatter = false): ChartSeries[] => {
+    const ParseSeries = (node: any, type?: ChartType): ChartSeries[] => {
 
       const series: ChartSeries[] = [];
 
@@ -447,7 +448,7 @@ export class Workbook {
           }
         }
 
-        if (scatter) {
+        if (type === ChartType.Scatter || type === ChartType.Bubble) {
           const x = XMLUtils.FindChild(series_node, 'c:xVal/c:numRef/c:f');
           if (x) {
             series_data.categories = x; // .text?.toString();
@@ -456,6 +457,14 @@ export class Workbook {
           if (y) {
             series_data.values = y; // .text?.toString();
           }
+
+          if (type === ChartType.Bubble) {
+            const z = XMLUtils.FindChild(series_node, 'c:bubbleSize/c:numRef/c:f');
+            if (z) {
+              series_data.bubble_size = z; // .text?.toString();
+            }
+          }
+
         }
         else {
           const value_node = XMLUtils.FindChild(series_node, 'c:val/c:numRef/c:f');
@@ -522,9 +531,23 @@ export class Workbook {
       node = XMLUtils.FindChild(xml, 'c:chartSpace/c:chart/c:plotArea/c:scatterChart');
       if (node) {
         result.type = ChartType.Scatter;
-        result.series = ParseSeries(node, true);
+        result.series = ParseSeries(node, ChartType.Scatter);
       }
     }
+
+    if (!node) {
+      node = XMLUtils.FindChild(xml, 'c:chartSpace/c:chart/c:plotArea/c:bubbleChart');
+      if (node) {
+        result.type = ChartType.Bubble;
+        result.series = ParseSeries(node, ChartType.Bubble);
+        console.info("Bubble series?", result.series);
+      }
+    }
+
+    if (!node) {
+      console.info("Chart type not handled");
+    }
+
     // console.info("RX?", result);
 
     return result;