@trebco/treb 28.10.5 → 28.13.2

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

@@ -81,7 +81,10 @@ export class Importer {
         t?: string;
         s?: string;
       };
-      v?: string|number; // is this never an object? (note: booleans are numbers in Excel)
+      v?: string|number|{
+        t$: string;
+        a$?: any;
+      }; 
       f?: string|{ 
         t$: string;
         a$?: {
@@ -214,14 +217,17 @@ export class Importer {
         }
 
         if (typeof element.v !== 'undefined') {
-          const num = Number(element.v.toString());
+
+          const V = (typeof element.v === 'object') ? element.v?.t$ : element.v;
+
+          const num = Number(V.toString());
           if (!isNaN(num)) {
             calculated_type = 'number'; // ValueType.number;
             calculated_value = num;
           }
           else {
             calculated_type = 'string'; // ValueType.string;
-            calculated_value = element.v.toString();
+            calculated_value = V.toString();
           }
         }
 
@@ -917,6 +923,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/workbook-style2.ts

@@ -29,6 +29,9 @@ import { XMLUtils } from './xml-utils';
 
 import { Unescape } from './unescape_xml';
 
+// what's the default font size? ... 11pt?
+const DEFAULT_FONT_SIZE = 11;
+
 export interface Font {
   size?: number;
   name?: string;
@@ -269,13 +272,24 @@ export class StyleCache {
 
     }
 
+
     if (composite.font_size?.unit && composite.font_size.value) {
-      if (composite.font_size.unit !== 'pt') {
-        console.warn(`can't handle non-point font (FIXME)`);
+      if (composite.font_size.unit === 'em') {
+        font.size = composite.font_size.value * DEFAULT_FONT_SIZE;
       }
-      else {
+      else if (composite.font_size.unit === '%') {
+        font.size = composite.font_size.value * DEFAULT_FONT_SIZE / 100;
+      }
+      else if (composite.font_size.unit === 'pt' ){
         font.size = composite.font_size.value;
       }
+      else if (composite.font_size.unit === 'px' ){
+        font.size = composite.font_size.value * .75; // ?
+      }
+      else {
+        console.warn(`Unhandled font size unit`, composite.font_size);
+      }
+
     }
 
     if (composite.bold) font.bold = true;
@@ -657,6 +671,19 @@ export class StyleCache {
 
     // borders
 
+    const BorderEdgeToColor = (edge: BorderEdge): Color|undefined => {
+
+      // TODO: indexed
+
+      if (typeof edge.theme !== 'undefined') {
+        return {
+          theme: edge.theme,
+          tint: edge.tint,
+        };
+      }
+
+    };
+
     const border = this.borders[xf.border || 0];
     if (border) {
       if (border.bottom.style) {
@@ -666,10 +693,20 @@ export class StyleCache {
         else {
           props.border_bottom = 1;
         }
+        props.border_bottom_fill = BorderEdgeToColor(border.bottom);
+      }
+      if (border.left.style) {
+        props.border_left = 1;
+        props.border_left_fill = BorderEdgeToColor(border.left);
+      }
+      if (border.top.style) {
+        props.border_top = 1;
+        props.border_top_fill = BorderEdgeToColor(border.top);
+      }
+      if (border.right.style) {
+        props.border_right = 1;
+        props.border_right_fill = BorderEdgeToColor(border.right);
       }
-      if (border.left.style) props.border_left = 1;
-      if (border.top.style) props.border_top = 1;
-      if (border.right.style) props.border_right = 1;
     }
 
     return props;
@@ -1144,31 +1181,58 @@ export class StyleCache {
 
     composite = FindAll('styleSheet/borders/border');
 
+    const ElementToBorderEdge = (element: any, edge: BorderEdge) => {
+
+      if (element?.a$) {
+        edge.style = element.a$.style;
+        if (typeof element.color === 'object') {
+          if (typeof element.color.a$?.indexed !== 'undefined') {
+            edge.color = Number(element.color.a$.indexed);
+          }
+          if (typeof element.color.a$?.theme !== 'undefined') {
+            edge.theme = Number(element.color.a$.theme);
+          }
+          if (typeof element.color.a$?.tint !== 'undefined') {
+            edge.tint = Number(element.color.a$.tint);
+          }
+        }
+      }
+
+    };
+    
+
     this.borders = composite.map(element => {
 
       const border: BorderStyle = JSON.parse(JSON.stringify(default_border));
 
+      /*
       // we're relying on these being empty strings -> falsy, not a good look
 
       if (element.left) {
-        border.left.style = element.left.a$.style;
-        border.left.color = Number(element.left.color?.a$?.indexed);
+        // border.left.style = element.left.a$.style;
+        // border.left.color = Number(element.left.color?.a$?.indexed);
       }
 
       if (element.right) {
-        border.right.style = element.right.a$.style;
-        border.right.color = Number(element.right.color?.a$?.indexed);
+        // border.right.style = element.right.a$.style;
+        // border.right.color = Number(element.right.color?.a$?.indexed);
       }
 
       if (element.top) {
-        border.top.style = element.top.a$.style;
-        border.top.color = Number(element.top.color?.a$?.indexed);
+        // border.top.style = element.top.a$.style;
+        // border.top.color = Number(element.top.color?.a$?.indexed);
       }
 
       if (element.bottom) {
-        border.bottom.style = element.bottom.a$.style;
-        border.bottom.color = Number(element.bottom.color?.a$?.indexed);
+        // border.bottom.style = element.bottom.a$.style;
+        // border.bottom.color = Number(element.bottom.color?.a$?.indexed);
       }
+      */
+
+      ElementToBorderEdge(element.left, border.left);
+      ElementToBorderEdge(element.right, border.right);
+      ElementToBorderEdge(element.top, border.top);
+      ElementToBorderEdge(element.bottom, border.bottom);
       
       return border;
 

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;

package/treb-grid/src/editors/editor.ts

@@ -789,6 +789,13 @@ export class Editor<E = FormulaEditorEvent> extends EventSource<E|FormulaEditorE
 
     if (this.active_editor && !this.assume_formula) {
       this.active_editor.node.spellcheck = !(this.text_formula);
+
+      // if not assuming formula, and it's not a formula, then exit.
+
+      if (!this.text_formula) {
+        return;
+      }
+
     }
 
     // this is a short-circuit so we don't format the same text twice. 

package/treb-grid/src/types/grid.ts

@@ -835,9 +835,9 @@ export class Grid extends GridBase {
     }
   }
 
-  /**
+  /* *
    * specialization: update selection, scroll offset
-   */
+   * /
   public Serialize(options: SerializeOptions = {}): SerializedModel {
 
     // selection moved to sheet, but it's not "live"; so we need to
@@ -855,6 +855,7 @@ export class Grid extends GridBase {
     return super.Serialize(options);
 
   }
+  */
 
   /**
    * show or hide headers
@@ -1830,18 +1831,23 @@ export class Grid extends GridBase {
         argument_separator: this.parser.argument_separator,
         decimal_mark: this.parser.decimal_mark,
       }
+
+      this.parser.Save();
+
       let convert = false;
 
       if (options.argument_separator === ',' && this.parser.argument_separator !== ArgumentSeparatorType.Comma) {
-        this.parser.argument_separator = ArgumentSeparatorType.Comma;
-        this.parser.decimal_mark = DecimalMarkType.Period;
+        // this.parser.argument_separator = ArgumentSeparatorType.Comma;
+        // this.parser.decimal_mark = DecimalMarkType.Period;
+        this.parser.SetLocaleSettings(DecimalMarkType.Period);
 
         convert = true;
       }
        
       if (options.argument_separator === ';' && this.parser.argument_separator !== ArgumentSeparatorType.Semicolon) {
-        this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
-        this.parser.decimal_mark = DecimalMarkType.Comma;
+        // this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
+        // this.parser.decimal_mark = DecimalMarkType.Comma;
+        this.parser.SetLocaleSettings(DecimalMarkType.Comma);
 
         convert = true;
       }
@@ -1882,8 +1888,10 @@ export class Grid extends GridBase {
 
       // reset
 
-      this.parser.argument_separator = current.argument_separator;
-      this.parser.decimal_mark = current.decimal_mark;
+      // this.parser.argument_separator = current.argument_separator;
+      // this.parser.decimal_mark = current.decimal_mark;
+
+      this.parser.Restore();
 
     }
       
@@ -4439,7 +4447,10 @@ export class Grid extends GridBase {
 
           if (this.overlay_editor?.selection) {
             const value = this.overlay_editor?.edit_node.textContent || undefined;
-            const array = (event.key === 'Enter' && event.ctrlKey && event.shiftKey);
+
+            // let's support command+shift+enter on mac
+            const array = (event.key === 'Enter' && (event.ctrlKey || (UA.is_mac && event.metaKey)) && event.shiftKey);
+
             this.SetInferredType(this.overlay_editor.selection, value, array);
           }
           

package/treb-grid/src/types/grid_base.ts

@@ -461,13 +461,19 @@ export class GridBase {
     // CSV assumes dot-decimal, correct? if we want to use the
     // parser we will have to check (and set/reset) the separator
 
+    this.parser.Save();
+    this.parser.SetLocaleSettings(DecimalMarkType.Period);
+
+    /*
     const toggle_separator = this.parser.decimal_mark === DecimalMarkType.Comma;
 
-    if (toggle_separator) {
+    if (toggle_separator) 
+    {
       // swap
       this.parser.argument_separator = ArgumentSeparatorType.Comma;
       this.parser.decimal_mark = DecimalMarkType.Period;
     }
+    */
 
     const records = ParseCSV(text);
     const arr = records.map((record) =>
@@ -481,11 +487,14 @@ export class GridBase {
         return ValueParser.TryParse(field).value;
       }));
 
+    /*
     if (toggle_separator) {
       // reset
       this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
       this.parser.decimal_mark = DecimalMarkType.Comma;
     }
+    */
+   this.parser.Restore();
   
     const end = {
       row: Math.max(0, arr.length - 1),
@@ -735,110 +744,6 @@ export class GridBase {
     this.model.user_data = undefined;
   }
 
-  /**
-   * serialize data. this function used to (optionally) stringify
-   * by typescript has a problem figuring this out, so we will simplify
-   * the function.
-   */
-  public Serialize(options: SerializeOptions = {}): SerializedModel {
-
-    // (removed UI stuff, that goes in subclass)
-
-    // selection moved to sheet, but it's not "live"; so we need to
-    // capture the primary selection in the current active sheet before
-    // we serialize it
-
-    // this.active_sheet.selection = JSON.parse(JSON.stringify(this.primary_selection));
-
-    // same for scroll offset
-
-    // this.active_sheet.scroll_offset = this.layout.scroll_offset;
-
-    // NOTE: annotations moved to sheets, they will be serialized in the sheets
-
-    const sheet_data = this.model.sheets.list.map((sheet) => sheet.toJSON(options));
-
-    // OK, not serializing tables in cells anymore. old comment about this:
-    // 
-    // at the moment, tables are being serialized in cells. if we put them
-    // in here, then we have two records of the same data. that would be bad.
-    // I think this is probably the correct place, but if we put them here
-    // we need to stop serializing in cells. and I'm not sure that there are 
-    // not some side-effects to that. hopefully not, but (...)
-    // 
-
-    let tables: Table[] | undefined;
-    if (this.model.tables.size > 0) {
-      tables = Array.from(this.model.tables.values());
-    }
-
-    // NOTE: moving into a structured object (the sheet data is also structured,
-    // of course) but we are moving things out of sheet (just  named ranges atm))
-
-    let macro_functions: MacroFunction[] | undefined;
-
-    if (this.model.macro_functions.size) {
-      macro_functions = [];
-      for (const macro of this.model.macro_functions.values()) {
-        macro_functions.push({
-          ...macro,
-          expression: undefined,
-        });
-      }
-    }
-
-    // when serializing named expressions, we have to make sure
-    // that there's a sheet name in any address/range. 
-
-    const named_expressions: SerializedNamedExpression[] = [];
-    if (this.model.named_expressions) {
-
-      for (const [name, expr] of this.model.named_expressions) {
-        this.parser.Walk(expr, unit => {
-          if (unit.type === 'address' || unit.type === 'range') {
-            const test = unit.type === 'range' ? unit.start : unit;
-
-            test.absolute_column = test.absolute_row = true;
-
-            if (!test.sheet) {
-              if (test.sheet_id) {
-                const sheet = this.model.sheets.Find(test.sheet_id);
-                if (sheet) {
-                  test.sheet = sheet.name;
-                }
-              }
-              if (!test.sheet) {
-                test.sheet = this.active_sheet.name;
-              }
-            }
-
-            if (unit.type === 'range') {
-              unit.end.absolute_column = unit.end.absolute_row = true;
-            }
-
-            return false;
-          }
-          return true;
-        });
-        const rendered = this.parser.Render(expr, { missing: '' });
-        named_expressions.push({
-          name, expression: rendered
-        });
-      }
-    }
-
-    return {
-      sheet_data,
-      active_sheet: this.active_sheet.id,
-      named_ranges: this.model.named_ranges.Count() ?
-        this.model.named_ranges.Serialize() :
-        undefined,
-      macro_functions,
-      tables,
-      named_expressions: named_expressions.length ? named_expressions : undefined,
-    };
-
-  }
 
   // --- protected methods -----------------------------------------------------
  

package/treb-grid/src/types/serialize_options.ts

@@ -69,4 +69,9 @@ export interface SerializeOptions {
   /** share resources (images, for now) to prevent writing data URIs more than once */
   share_resources?: boolean;
 
+  /**
+   * if a function has an export() handler, call that
+   */
+  export_functions?: boolean;
+
 }