@trebco/treb 28.10.0 → 28.11.1

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;

package/treb-grid/src/index.ts

@@ -22,7 +22,7 @@
 export { Grid } from './types/grid';
 export { GridBase } from './types/grid_base';
 export { Sheet } from './types/sheet';
-export { DataModel, type MacroFunction } from './types/data_model';
+export { DataModel, type MacroFunction, type ConnectedElementType } from './types/data_model';
 export type { SerializedNamedExpression, SerializedModel } from './types/data_model';
 export * from './types/grid_events';
 export type { SerializedSheet, FreezePane } from './types/sheet_types';

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

@@ -26,6 +26,12 @@ import { NamedRangeCollection } from './named_range';
 import { type ExpressionUnit, type UnitAddress, type UnitStructuredReference, type UnitRange, Parser, QuotedSheetNameRegex } from 'treb-parser';
 import { Area, IsCellAddress, Style } from 'treb-base-types';
 
+export interface ConnectedElementType {
+  formula: string;
+  update?: (instance: ConnectedElementType) => void;
+  internal?: unknown; // opaque type to prevent circular dependencies
+}
+
 export interface SerializedMacroFunction {
   name: string;
   function_def: string;
@@ -444,6 +450,32 @@ export class DataModel {
     return address; // already range or address
 
   }
+  
+  public AddConnectedElement(connected_element: ConnectedElementType): number {
+    const id = this.connected_element_id++;
+    this.connected_elements.set(id, connected_element);
+    return id;
+  }
+
+  public RemoveConnectedElement(id: number) {
+    const element = this.connected_elements.get(id);
+    this.connected_elements.delete(id);
+    return element;
+  }
+
+  /** 
+   * identifier for connected elements, used to manage. these need to be 
+   * unique in the lifetime of a model instance, but no more than that.
+   */
+  protected connected_element_id = 100;
+
+  /** 
+   * these are intentionally NOT serialized. they're ephemeral, created 
+   * at runtime and not persistent.
+   * 
+   * @internal
+   */
+  public connected_elements: Map<number, ConnectedElementType> = new Map();
 
 }
 

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

@@ -2270,6 +2270,16 @@ export class GridBase {
       }
     }
 
+    for (const element of this.model.connected_elements.values()) {
+      if (element.formula) {
+        const updated = this.PatchExpressionSheetName(element.formula, old_name, name);
+        if (updated) {
+          element.formula = updated;
+          changes++;
+        }
+      }
+    }
+
     return changes;
 
   }
@@ -2850,6 +2860,18 @@ export class GridBase {
         row_count: command.count
       });
 
+    // connected elements
+    for (const external of this.model.connected_elements.values()) {
+      if (external.formula) {
+        const modified = this.PatchFormulasInternal(external.formula,
+          command.before_row, command.count, 0, 0,
+          target_sheet.name.toLowerCase(), false);
+        if (modified) {
+          external.formula = modified;
+        }
+      }
+    }
+
     // see InsertColumnsInternal re: tables. rows are less complicated,
     // except that if you delete the header row we want to remove the 
     // table entirely.
@@ -3172,6 +3194,18 @@ export class GridBase {
       before_row: 0, 
       row_count: 0 });
 
+    // connected elements
+    for (const element of this.model.connected_elements.values()) {
+      if (element.formula) {
+        const modified = this.PatchFormulasInternal(element.formula,
+          0, 0, command.before_column, command.count,
+          target_sheet.name.toLowerCase(), false);
+        if (modified) {
+          element.formula = modified;
+        }
+      }
+    }
+
     // patch tables. we removed this from the sheet routine entirely,
     // we need to rebuild any affected tables now.
 

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

@@ -395,3 +395,9 @@ export interface RenderOptions {
   long_structured_references: boolean;
   table_name: string;
 }
+
+export interface PersistedParserConfig {
+  flags: Partial<ParserFlags>;
+  argument_separator: ArgumentSeparatorType;
+  decimal_mark: DecimalMarkType;
+}

package/treb-parser/src/parser.ts

@@ -33,7 +33,8 @@ import type {
   UnitLiteralNumber,
   ParserFlags,
   UnitStructuredReference,
-  RenderOptions} from './parser-types';
+  RenderOptions,
+  PersistedParserConfig} from './parser-types';
 import {
   ArgumentSeparatorType,
   DecimalMarkType
@@ -248,6 +249,52 @@ export class Parser {
    */
   protected full_reference_list: Array<UnitAddress | UnitRange | UnitIdentifier | UnitStructuredReference> = [];
 
+  protected parser_state: string[] = [];
+
+  /**
+   * save local configuration to a buffer, so it can be restored. we're doing
+   * this because in a lot of places we're caching parser flagss, changing
+   * them, and then restoring them. that's become repetitive, fragile to 
+   * changes or new flags, and annoying.
+   * 
+   * config is managed in a list with push/pop semantics. we store it as 
+   * JSON so there's no possibility we'll accidentally mutate.
+   * 
+   * FIXME: while we're at it why not migrate the separators -> flags, so
+   * there's a single location for this kind of state? (...TODO)
+   * 
+   */
+  public Save() {
+    const config: PersistedParserConfig = {
+      flags: this.flags,
+      argument_separator: this.argument_separator,
+      decimal_mark: this.decimal_mark,
+    }
+    this.parser_state.push(JSON.stringify(config));
+  }
+
+  /**
+   * restore persisted config
+   * @see Save
+   */
+  public Restore() {
+    const json = this.parser_state.shift();
+    if (json) {
+      try {
+        const config = JSON.parse(json) as PersistedParserConfig;
+        this.flags = config.flags;
+        this.argument_separator = config.argument_separator;
+        this.decimal_mark = config.decimal_mark;
+      }
+      catch (err) {
+        console.error(err);
+      }
+    }
+    else {
+      console.warn("No parser state to restore");
+    }
+  }
+
   /**
    * recursive tree walk.
    *