@trebco/treb 28.10.0 → 28.10.5

package/treb-embed/src/embedded-spreadsheet.ts

@@ -87,6 +87,10 @@ import type { BorderToolbarMessage, ToolbarMessage } from './toolbar-message';
 import { Chart, ChartFunctions } from 'treb-charts';
 import type { SetRangeOptions } from 'treb-grid';
 
+import type { StateLeafVertex } from 'treb-calculator';
+import type { ConnectedElementType } from 'treb-grid';
+
+
 // --- worker ------------------------------------------------------------------
 
 /**
@@ -95,7 +99,6 @@ import type { SetRangeOptions } from 'treb-grid';
  * the script so we can run it as a worker.
  */
 import * as export_worker_script from 'worker:../../treb-export/src/export-worker/index.worker';
-import { StateLeafVertex } from 'treb-calculator/src/dag/state_leaf_vertex';
 
 // --- types -------------------------------------------------------------------
 
@@ -2197,6 +2200,114 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
   }
 
+  public RemoveConnectedChart(id: number) {
+    const element = this.model.RemoveConnectedElement(id);
+    if (element) {
+      const removed = this.calculator.RemoveConnectedELement(element);
+      if (removed) {
+        // ... actually don't need to update here
+      }
+    }
+  }
+
+  public UpdateConnectedChart(id: number, formula: string) {
+    const element = this.model.connected_elements.get(id);
+    if (element) {
+      element.formula = formula;
+      const internal = (element.internal) as { vertex: StateLeafVertex, state: any };
+
+      if (internal?.state) {
+        internal.state = undefined;
+      }
+      this.calculator.UpdateConnectedElements(this.grid.active_sheet, element);     
+      
+      if (element.update) {
+        element.update.call(0, element);
+      }
+
+    }
+  }
+
+  /**
+   * @internal
+   * 
+   * @returns an id that can be used to manage the reference
+   */
+  public CreateConnectedChart(formula: string, target: HTMLElement, options: EvaluateOptions): number {
+
+    // FIXME: merge w/ insert annotation?
+
+    let r1c1 = options?.r1c1 || false;
+    let argument_separator = options?.argument_separator || this.parser.argument_separator; // default to current
+
+    this.parser.Save();
+    this.parser.flags.r1c1 = r1c1;
+
+    if (argument_separator === ',') {
+      this.parser.argument_separator = ArgumentSeparatorType.Comma;
+      this.parser.decimal_mark = DecimalMarkType.Period;
+    }
+    else {
+      this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
+      this.parser.decimal_mark = DecimalMarkType.Comma;
+    }
+
+    const result = this.parser.Parse(formula);
+
+    this.parser.Restore();
+
+    if (result.expression) {
+      formula = '=' + this.parser.Render(result.expression, { missing: '' });
+    }
+    else {
+      console.warn("invalid formula", result.error);
+    }
+
+    const chart = this.CreateChart();
+    chart.Initialize(target);
+
+    const id = this.model.AddConnectedElement({
+      formula,
+
+      // this is circular, but I want to leave `this` bound to the sheet
+      // instance in case we need it -- so what's a better approach? pass
+      // in the formula explicitly, and update if we need to make changes?
+
+      update: (instance: ConnectedElementType) => {
+
+        const parse_result = this.parser.Parse(instance.formula);
+
+        if (parse_result &&
+          parse_result.expression &&
+          parse_result.expression.type === 'call') {
+
+          // FIXME: make a method for doing this
+
+          this.parser.Walk(parse_result.expression, (unit) => {
+            if (unit.type === 'address' || unit.type === 'range') {
+              this.model.ResolveSheetID(unit, undefined, this.grid.active_sheet);
+            }
+            return true;
+          });
+
+          const expr_name = parse_result.expression.name.toLowerCase();
+          const result = this.calculator.CalculateExpression(parse_result.expression);
+          chart.Exec(expr_name, result as ExtendedUnion); // FIXME: type?
+        }
+
+        chart.Update();
+
+      },
+
+    });
+
+    this.calculator.UpdateConnectedElements(this.grid.active_sheet);
+    this.UpdateConnectedElements();
+
+    return id;
+
+  }
+
   /**
    * Insert an annotation node. Usually this means inserting a chart. Regarding
    * the argument separator, see the Evaluate function.
@@ -2226,11 +2337,21 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       target = Rectangle.IsRectangle(rect) ? rect : this.model.ResolveArea(rect, this.grid.active_sheet);
     }
 
+    // FIXME: with the new parser save/restore semantics we should 
+    // just always do this. also I don't think the r1c1 logic works
+    // properly here... unless we're assuming that the default state
+    // is always off
+
     if (argument_separator && argument_separator !== this.parser.argument_separator || r1c1) {
+
+      this.parser.Save();
+
+      /*
       const current = {
         argument_separator: this.parser.argument_separator, 
         decimal_mark: this.parser.decimal_mark,
       };
+      */
 
       if (argument_separator === ',') {
         this.parser.argument_separator = ArgumentSeparatorType.Comma;
@@ -2241,17 +2362,21 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
         this.parser.decimal_mark = DecimalMarkType.Comma;
       }
 
-      const r1c1_state = this.parser.flags.r1c1;
-      if (r1c1) {
-        this.parser.flags.r1c1 = r1c1;
-      }
+      // const r1c1_state = this.parser.flags.r1c1;
+      // if (r1c1) 
+      // {
+        this.parser.flags.r1c1 = !!r1c1;
+      // }
 
       const result = this.parser.Parse(formula);
       
+      /*
       // reset
       this.parser.argument_separator = current.argument_separator;
       this.parser.decimal_mark = current.decimal_mark;
       this.parser.flags.r1c1 = r1c1_state;
+      */
+      this.parser.Restore();
 
       if (result.expression) {
         formula = '=' + this.parser.Render(result.expression, { missing: '' });
@@ -4856,6 +4981,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    * (just sparklines atm) and update if necessary.
    */
   protected UpdateAnnotations(): void {
+
     for (const annotation of this.grid.active_sheet.annotations) {
       if (annotation.temp.vertex) {
         const vertex = annotation.temp.vertex as StateLeafVertex;
@@ -4893,6 +5019,27 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       }
 
     }
+
+    this.UpdateConnectedElements();
+
+  }
+
+  protected UpdateConnectedElements() {
+    for (const element of this.model.connected_elements.values()) {
+      const internal = (element.internal) as { vertex: StateLeafVertex, state: any };
+      if (internal?.vertex && internal.vertex.state_id !== internal.state ) {
+        internal.state = internal.vertex.state_id;
+        const fn = element.update; 
+        if (fn) {
+
+          // FIXME: what if there are multiple calls pending? some 
+          // kind of a dispatch system might be useful
+
+          Promise.resolve().then(() => fn.call(0, element));
+
+        }
+      }
+    }
   }
 
   /*

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.
    *