@trebco/treb 27.5.3 → 27.9.0

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

@@ -31,34 +31,48 @@ import type {
   GridSelection, CellEvent, FunctionDescriptor, 
   AnnotationViewData,
   AnnotationType, 
-  ExternalEditorType,
+  ExternalEditorConfig,
+  ConditionalFormatDuplicateValuesOptions,
+  ConditionalFormatDuplicateValues,
+  ConditionalFormatGradientOptions,
+  ConditionalFormat, 
+  ConditionalFormatGradient, 
+  ConditionalFormatExpression,
+  StandardGradient,
+  CondifionalFormatExpressionOptions,
+  ConditionalFormatCellMatchOptions,
+  ConditionalFormatCellMatch,
 } from 'treb-grid';
 
 import {
-  DataModel, Grid, BorderConstants, Sheet, ErrorCode, UA
+  DataModel, Grid, BorderConstants, Sheet, ErrorCode, UA,
+  StandardGradientsList,
 } from 'treb-grid';
 
 import { 
   Parser, DecimalMarkType, 
   ArgumentSeparatorType, QuotedSheetNameRegex } from 'treb-parser';
 
-import { Calculator, type EvaluateOptions, type LeafVertex } from 'treb-calculator';
+import { Calculator, type LeafVertex } from 'treb-calculator';
 
 import type {
   ICellAddress, 
+  EvaluateOptions,
   IArea, CellValue, Point,
   Complex, ExtendedUnion, IRectangle,
-  AddressReference, RangeReference, TableSortOptions, Table, TableTheme,
+  AddressReference, RangeReference, TableSortOptions, Table, TableTheme, GradientStop,
 } from 'treb-base-types';
 
 import {
   IsArea, ThemeColorTable, ComplexToString, Rectangle, IsComplex, type CellStyle,
-  Localization, Style, type Color, ThemeColor2, IsCellAddress, Area, IsFlatData, IsFlatDataArray, 
+  Localization, Style, type Color, ThemeColor2, IsCellAddress, Area, IsFlatData, IsFlatDataArray, Gradient, ValueType, 
 } from 'treb-base-types';
 
 import { EventSource, Yield, ValidateURI } from 'treb-utils';
 import { NumberFormatCache, ValueParser, NumberFormat } from 'treb-format';
 
+
+
 // --- local -------------------------------------------------------------------
 
 import { Dialog, DialogType } from './progress-dialog';
@@ -81,6 +95,7 @@ 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 -------------------------------------------------------------------
 
@@ -355,7 +370,7 @@ export class EmbeddedSpreadsheet {
 
   /** localized parser instance. we're sharing. */
   protected get parser(): Parser {
-    return this.calculator.parser;
+    return this.model.parser;
   }
 
   /** for destruction */
@@ -659,7 +674,7 @@ export class EmbeddedSpreadsheet {
     // if we don't have a container. that's distinct (at the moment)
     // from headless, which is a state that can change.
 
-    this.grid = new Grid(grid_options, this.parser, this.model, undefined, !!container);
+    this.grid = new Grid(grid_options, this.model, undefined, !!container);
 
     if (this.options.headless) {
       this.grid.headless = true; // FIXME: move into grid options
@@ -1177,8 +1192,8 @@ export class EmbeddedSpreadsheet {
    * to support outside tooling by highlighting a list of arguments and 
    * responding to selection.
    */
-  public ExternalEditor(editor?: Partial<ExternalEditorType>) {
-    this.grid.ExternalEditor(editor);
+  public ExternalEditor(config?: Partial<ExternalEditorConfig>) {
+    this.grid.ExternalEditor(config);
   }
 
   /**
@@ -1251,6 +1266,265 @@ export class EmbeddedSpreadsheet {
 
   }
 
+  //////////////////////////////////////////////////////////////////////////////
+  //
+  // conditional formatting API (WIP)
+  //
+
+  /**
+   * list conditional formats. uses the active sheet by default, or pass a 
+   * sheet name or id.
+   * 
+   * @internal
+   */
+  public ListConditionalFormats(sheet?: number|string) {
+
+    const target = (typeof sheet === 'undefined') ? 
+      this.grid.active_sheet :
+      this.model.sheets.Find(sheet);
+
+    return target?.conditional_formats || [];
+      
+  }
+
+  /** @internal */
+  public ConditionalFormatDuplicateValues(range: RangeReference|undefined, options: ConditionalFormatDuplicateValuesOptions): ConditionalFormat {
+       
+    if (range === undefined) {
+      const ref = this.GetSelectionReference();
+      if (ref.empty) {
+        throw new Error('invalid range (no selection)');
+      }
+      range = ref.area;
+    }
+    
+    return this.AddConditionalFormat({
+        type: 'duplicate-values',
+        area: this.model.ResolveArea(range, this.grid.active_sheet),
+        ...options,
+      });
+
+  }
+
+  /**
+   * @internal
+   */
+  public ConditionalFormatGradient(range: RangeReference|undefined, options: ConditionalFormatGradientOptions|StandardGradient): ConditionalFormat {
+
+    if (range === undefined) {
+      const ref = this.GetSelectionReference();
+      if (ref.empty) {
+        throw new Error('invalid range (no selection)');
+      }
+      range = ref.area;
+    }
+    
+    const area = this.model.ResolveArea(range, this.grid.active_sheet);
+
+    const format: ConditionalFormatGradient = (typeof options === 'object') ?
+      {
+        type: 'gradient', area, ...options,
+      } :
+      {
+        type: 'gradient', area, ...StandardGradientsList[options]
+      };
+
+    this.AddConditionalFormat(format);
+    return format;
+
+  }
+
+  /** @internal */
+  public ConditionalFormatCellMatch(range: RangeReference|undefined, options: ConditionalFormatCellMatchOptions): ConditionalFormat {
+
+    if (range === undefined) {
+      const ref = this.GetSelectionReference();
+      if (ref.empty) {
+        throw new Error('invalid range (no selection)');
+      }
+      range = ref.area;
+    }
+    
+    const area = this.model.ResolveArea(range, this.grid.active_sheet);
+
+    const format: ConditionalFormatCellMatch = {
+      type: 'cell-match',
+      area,
+      ...options,
+    };
+
+    // we need to calculate the formula once, to get an initial state
+    // update: internal
+    // let result = this.Evaluate(this.Unresolve(area, true, false) + ' ' + options.expression, options.options);
+
+    // ... apply ...
+
+    this.AddConditionalFormat(format);
+    return format;
+
+
+  }
+
+  /**
+   * @internal
+   */
+  public ConditionalFormatExpression(range: RangeReference|undefined, options: CondifionalFormatExpressionOptions): ConditionalFormat {
+
+    if (range === undefined) {
+      const ref = this.GetSelectionReference();
+      if (ref.empty) {
+        throw new Error('invalid range (no selection)');
+      }
+      range = ref.area;
+    }
+    
+    const area = this.model.ResolveArea(range, this.grid.active_sheet);
+
+    const format: ConditionalFormatExpression = {
+      type: 'expression',
+      area,
+      ...options,
+    };
+
+    /*
+    // we need to calculate the formula once, to get an initial state
+    let result = this.Evaluate(options.expression, options.options);
+
+    if (Array.isArray(result)) {
+      result = result[0][0];
+    }
+    const applied = !!result;
+    
+    this.AddConditionalFormat({...format, applied });
+    */
+
+    this.AddConditionalFormat(format);
+
+    return format;
+
+  }
+
+  /**
+   * add a conditional format
+   * 
+   * @internal
+   */
+  public AddConditionalFormat(format: ConditionalFormat) {
+
+    const sheet = this.model.sheets.Find(format.area.start.sheet_id||0);
+    
+    if (!sheet) {
+      throw new Error('invalid reference in format');
+    }
+
+    sheet.conditional_formats.push(format);
+
+    this.calculator.UpdateConditionals(format, sheet);
+
+    // call update if it's the current sheet
+    this.ApplyConditionalFormats(sheet, sheet === this.grid.active_sheet);
+
+    this.PushUndo();
+
+    // fluent
+    return format;
+
+  }
+
+  /**
+   * remove conditional format
+   * 
+   * @internal
+   */
+  public RemoveConditionalFormat(format: ConditionalFormat) {
+    const area = format.area;
+    const sheet = area.start.sheet_id ? this.model.sheets.Find(area.start.sheet_id) : this.grid.active_sheet;
+
+    if (!sheet) {
+      throw new Error('invalid reference in format');
+    }
+
+    let count = 0;
+    sheet.conditional_formats = sheet.conditional_formats.filter(test => {
+      if (test === format) {
+        count++;
+        this.calculator.RemoveConditional(test);
+        return false;
+      }
+      return true;
+    });
+
+    if (count) {
+      sheet.FlushConditionalFormats();
+    }
+
+    // we want to call update if it's the current sheet,
+    // but we want a full repaint
+
+    this.ApplyConditionalFormats(sheet, false);
+
+    if (sheet === this.grid.active_sheet) {
+      this.grid.Update(true);
+    }
+
+    if (count) {
+      this.PushUndo();
+    }
+
+  }
+
+  /**
+   * clear conditional formats from the target range (or currently selected
+   * range). we operate on format objects, meaning we'll remove the whole
+   * format object rather than clip the area.
+   * 
+   * @internal
+   */
+  public RemoveConditionalFormats(range?: RangeReference) {
+
+    if (range === undefined) {
+      const ref = this.GetSelectionReference();
+      if (ref.empty) {
+        throw new Error('invalid range (no selection)');
+      }
+      range = ref.area;
+    }
+    const area = this.model.ResolveArea(range, this.grid.active_sheet);
+    const sheet = area.start.sheet_id ? this.model.sheets.Find(area.start.sheet_id) : this.grid.active_sheet;
+
+    if (sheet) {
+      let count = 0;
+
+      sheet.conditional_formats = sheet.conditional_formats.filter(test => {
+        const compare = new Area(test.area.start, test.area.end);
+        if (compare.Intersects(area)) {
+          count++;
+          this.calculator.RemoveConditional(test);
+          return false;
+        }
+        return true;
+      });
+
+      if (count) {
+
+        sheet.FlushConditionalFormats();
+
+        this.ApplyConditionalFormats(sheet, false);
+    
+        if (sheet === this.grid.active_sheet) {
+          this.grid.Update(true);
+        }
+
+        this.PushUndo();
+      }
+
+    }
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
   /**
    * @internal
    */
@@ -1794,6 +2068,19 @@ export class EmbeddedSpreadsheet {
 
     this.UpdateDocumentStyles();
 
+    // we need to flush conditional formats that use theme colors
+    // (I guess we're just flushing everybody?)
+
+    for (const sheet of this.model.sheets.list) {
+      for (const format of sheet.conditional_formats) {
+        format.internal = undefined;
+      }
+    }
+
+    this.calculator.UpdateConditionals();
+    this.ApplyConditionalFormats(this.grid.active_sheet, false);
+    this.grid.Update(true);
+
   }
 
   /**
@@ -1846,7 +2133,7 @@ export class EmbeddedSpreadsheet {
    * @param reference 
    */
   public InsertTable(range?: RangeReference, options: InsertTableOptions = {}) {
-    const area = range ? this.calculator.ResolveArea(range, this.grid.active_sheet) : this.GetSelectionReference().area;
+    const area = range ? this.model.ResolveArea(range, this.grid.active_sheet) : this.GetSelectionReference().area;
 
     let theme = options.theme;
     if (typeof theme === 'number') {
@@ -1928,7 +2215,7 @@ export class EmbeddedSpreadsheet {
     let target: IRectangle | Partial<Area> | undefined;
 
     if (rect) {
-      target = Rectangle.IsRectangle(rect) ? rect : this.calculator.ResolveArea(rect, this.grid.active_sheet);
+      target = Rectangle.IsRectangle(rect) ? rect : this.model.ResolveArea(rect, this.grid.active_sheet);
     }
 
     if (argument_separator && argument_separator !== this.parser.argument_separator) {
@@ -2273,7 +2560,7 @@ export class EmbeddedSpreadsheet {
 
     // API v1 OK
 
-    this.grid.MergeCells(range ? this.calculator.ResolveArea(range, this.grid.active_sheet) : undefined);
+    this.grid.MergeCells(range ? this.model.ResolveArea(range, this.grid.active_sheet) : undefined);
   }
 
   /**
@@ -2287,7 +2574,7 @@ export class EmbeddedSpreadsheet {
 
     // API v1 OK
 
-    this.grid.UnmergeCells(range ? this.calculator.ResolveArea(range, this.grid.active_sheet) : undefined);
+    this.grid.UnmergeCells(range ? this.model.ResolveArea(range, this.grid.active_sheet) : undefined);
   }
 
   /** 
@@ -2954,11 +3241,11 @@ export class EmbeddedSpreadsheet {
     // FIXME: optional? parameter? (...)
 
     if (data.rendered_values && !options.recalculate) {
-      this.grid.Update();
       this.calculator.RebuildClean(true);
+      this.ApplyConditionalFormats(this.grid.active_sheet, false);
+      this.grid.Update();
     }
     else {
-      // console.info('load recalc');
       this.Recalculate();
     }
 
@@ -2996,7 +3283,7 @@ export class EmbeddedSpreadsheet {
     // API v1 OK
 
     if (typeof address === 'string') {
-      const reference = this.calculator.ResolveAddress(address, this.grid.active_sheet);
+      const reference = this.model.ResolveAddress(address, this.grid.active_sheet);
       address = IsCellAddress(reference) ? reference : reference.start;
     }
 
@@ -3016,7 +3303,7 @@ export class EmbeddedSpreadsheet {
   public SetValidation(address: AddressReference, validation?: RangeReference|CellValue[], error?: boolean) {
 
     if (typeof address === 'string') {
-      const reference = this.calculator.ResolveAddress(address, this.grid.active_sheet);
+      const reference = this.model.ResolveAddress(address, this.grid.active_sheet);
       address = IsCellAddress(reference) ? reference : reference.start;
     }
 
@@ -3024,7 +3311,7 @@ export class EmbeddedSpreadsheet {
       this.grid.SetValidation(address, validation, error);
     }
     else {
-      const range = this.calculator.ResolveArea(validation, this.grid.active_sheet);
+      const range = this.model.ResolveArea(validation, this.grid.active_sheet);
       this.grid.SetValidation(address, range, error);
     }
 
@@ -3034,7 +3321,7 @@ export class EmbeddedSpreadsheet {
   public RemoveValidation(address: AddressReference) {
 
     if (typeof address === 'string') {
-      const reference = this.calculator.ResolveAddress(address);
+      const reference = this.model.ResolveAddress(address);
       address = IsCellAddress(reference) ? reference : reference.start;
     }
 
@@ -3045,7 +3332,7 @@ export class EmbeddedSpreadsheet {
   public SetValidationList(address: AddressReference, list: CellValue[]) {
 
     if (typeof address === 'string') {
-      const reference = this.calculator.ResolveAddress(address);
+      const reference = this.model.ResolveAddress(address);
       address = IsCellAddress(reference) ? reference : reference.start;
     }
 
@@ -3056,11 +3343,11 @@ export class EmbeddedSpreadsheet {
   public SetValidationRange(address: AddressReference, range: RangeReference) {
 
     if (typeof address === 'string') {
-      const reference = this.calculator.ResolveAddress(address);
+      const reference = this.model.ResolveAddress(address);
       address = IsCellAddress(reference) ? reference : reference.start;
     }
 
-    range = this.calculator.ResolveArea(range);
+    range = this.model.ResolveArea(range);
     this.grid.SetValidation(address, range);
 
   }
@@ -3248,6 +3535,7 @@ export class EmbeddedSpreadsheet {
     }
 
     this.calculator.Calculate(area);
+    this.ApplyConditionalFormats(this.grid.active_sheet, false);
 
     this.grid.Update(true); // , area);
     this.UpdateAnnotations();
@@ -3364,7 +3652,7 @@ export class EmbeddedSpreadsheet {
     // API v1 OK
 
     if (typeof address === 'string') {
-      const reference = this.calculator.ResolveAddress(address, this.grid.active_sheet);
+      const reference = this.model.ResolveAddress(address, this.grid.active_sheet);
       address = IsCellAddress(reference) ? reference : reference.start;
     }
 
@@ -3404,7 +3692,7 @@ export class EmbeddedSpreadsheet {
     // FIXME: we're using the sheet EnsureAddress method, but that should
     // move either in here or into some sort of helper class
 
-    const result = this.calculator.ResolveAddress(reference, this.grid.active_sheet);
+    const result = this.model.ResolveAddress(reference, this.grid.active_sheet);
 
     if (IsCellAddress(result)) {
       return result.sheet_id ? result : undefined;
@@ -3432,6 +3720,9 @@ export class EmbeddedSpreadsheet {
       ref = resolved;
     }
 
+    return this.calculator.Unresolve(ref, this.grid.active_sheet, qualified, named);
+
+    /*
     let range = '';
     const area = IsCellAddress(ref) ? new Area(ref) : new Area(ref.start, ref.end);
 
@@ -3457,10 +3748,11 @@ export class EmbeddedSpreadsheet {
     // the active selection must be on the active sheet? (...)
 
     const sheet_id = area.start.sheet_id || this.grid.active_sheet.id;
-    const sheet_name = this.ResolveSheetName(sheet_id, true);
+    const sheet_name = this.calculator.ResolveSheetName(sheet_id, true);
 
     return sheet_name ? sheet_name + '!' + range : range;
-    
+    */
+
   }
   
   /**
@@ -3482,7 +3774,7 @@ export class EmbeddedSpreadsheet {
 
     return this.calculator.Evaluate(
         expression, this.grid.active_sheet, options);
-
+   
   }
 
   /**
@@ -3522,7 +3814,7 @@ export class EmbeddedSpreadsheet {
     // the active selection must be on the active sheet? (...)
 
     const sheet_id = ref.area.start.sheet_id || this.grid.active_sheet.id;
-    const sheet_name = this.ResolveSheetName(sheet_id, true);
+    const sheet_name = this.calculator.ResolveSheetName(sheet_id, true);
 
     return sheet_name ? sheet_name + '!' + range : range;
 
@@ -3600,7 +3892,7 @@ export class EmbeddedSpreadsheet {
 
     // still for now we can take advantage of that and skip the check.
 
-    this.grid.ApplyBorders2(range ? this.calculator.ResolveArea(range, this.grid.active_sheet) : undefined, borders, {}, width);
+    this.grid.ApplyBorders2(range ? this.model.ResolveArea(range, this.grid.active_sheet) : undefined, borders, {}, width);
 
   }
 
@@ -3623,7 +3915,7 @@ export class EmbeddedSpreadsheet {
     // translate old-style alignment constants (UPDATE: moved to grid)
 
     this.grid.ApplyStyle(
-      range ? this.calculator.ResolveArea(range, this.grid.active_sheet) : undefined, style, delta);
+      range ? this.model.ResolveArea(range, this.grid.active_sheet) : undefined, style, delta);
   }
 
   /**
@@ -3687,7 +3979,7 @@ export class EmbeddedSpreadsheet {
 
     if (typeof value === 'object') {
       if (IsCellAddress(value) || IsArea(value)) {
-        this.grid.SetName(name, this.calculator.ResolveArea(value, this.grid.active_sheet));
+        this.grid.SetName(name, this.model.ResolveArea(value, this.grid.active_sheet));
         return;
       }
     }
@@ -3704,7 +3996,7 @@ export class EmbeddedSpreadsheet {
       switch (parse_result.expression.type) {
         case 'address':
         case 'range':
-          this.grid.SetName(name, this.calculator.ResolveArea(parse_result.expression, this.grid.active_sheet));
+          this.grid.SetName(name, this.model.ResolveArea(parse_result.expression, this.grid.active_sheet));
           return;
       }
       this.grid.SetName(name, undefined, value);
@@ -3730,7 +4022,7 @@ export class EmbeddedSpreadsheet {
 
     // NOTE: AC is handled internally
 
-    this.grid.SetName(name, this.calculator.ResolveArea(range, this.grid.active_sheet));
+    this.grid.SetName(name, this.model.ResolveArea(range, this.grid.active_sheet));
     */
   }
 
@@ -3756,7 +4048,7 @@ export class EmbeddedSpreadsheet {
     // API v1 OK
 
     if (typeof address === 'string') {
-      const reference = this.calculator.ResolveAddress(address, this.grid.active_sheet);
+      const reference = this.model.ResolveAddress(address, this.grid.active_sheet);
       address = IsCellAddress(reference) ? reference : reference.start;
     }
 
@@ -3784,7 +4076,7 @@ export class EmbeddedSpreadsheet {
     let resolved: Area|undefined = undefined; 
 
     if (!!range) {
-      resolved = this.calculator.ResolveArea(range, this.grid.active_sheet);
+      resolved = this.model.ResolveArea(range, this.grid.active_sheet);
       if (resolved.start.sheet_id) {
         if (resolved.start.sheet_id !== this.grid.active_sheet.id) {
           this.grid.ActivateSheetID(resolved.start.sheet_id);
@@ -3826,7 +4118,7 @@ export class EmbeddedSpreadsheet {
       }
     }
 
-    return this.grid.GetRange(this.calculator.ResolveAddress(range, this.grid.active_sheet), options.type);
+    return this.grid.GetRange(this.model.ResolveAddress(range, this.grid.active_sheet), options.type);
 
   }
 
@@ -3855,7 +4147,7 @@ export class EmbeddedSpreadsheet {
 
     if (!range) { return undefined; }
 
-    return this.grid.GetRangeStyle(this.calculator.ResolveAddress(range, this.grid.active_sheet), apply_theme);
+    return this.grid.GetRangeStyle(this.model.ResolveAddress(range, this.grid.active_sheet), apply_theme);
     
   }
 
@@ -3884,7 +4176,7 @@ export class EmbeddedSpreadsheet {
     }
 
     if (range) {
-      const area = this.calculator.ResolveArea(range, this.grid.active_sheet);
+      const area = this.model.ResolveArea(range, this.grid.active_sheet);
 
       if (options.spill && Array.isArray(data)) {
         const rows = data.length;
@@ -3940,6 +4232,47 @@ export class EmbeddedSpreadsheet {
 
   // --- internal (protected) methods ------------------------------------------
 
+  /**
+   * 
+   */
+  protected ApplyConditionalFormats(sheet: Sheet, call_update: boolean) {
+
+    // const sheet = this.grid.active_sheet;
+    const areas: IArea[] = [];
+
+    if (sheet.conditional_formats.length || sheet.flush_conditional_formats) {
+
+      for (const entry of sheet.conditional_formats) {
+        areas.push(entry.area);
+
+        // NOTE: we're (optionally) adding the gradient here, instead
+        // of when it's created, because we might want to flush this
+        // from time to time. specifically, because gradient might use
+        // theme colors, we need to flush it when the theme is updated.
+
+        // so don't move it, even though it is tempting. or rewrite to 
+        // update on theme changes.
+
+        if (entry.type === 'gradient') {
+          if (!entry.internal) {
+            entry.internal = {};
+          }
+          if (!entry.internal.gradient) {
+            entry.internal.gradient = new Gradient(entry.stops, this.grid.theme, entry.color_space);
+          }
+        }
+      }
+
+      sheet.ApplyConditionalFormats();
+
+    }
+
+    if (call_update) {
+      this.grid.Update(true, areas);
+    }
+
+  }
+
   protected ResolveTable(reference: RangeReference): Table|undefined {
 
     let table: Table|undefined = undefined;
@@ -3953,7 +4286,7 @@ export class EmbeddedSpreadsheet {
 
     if (!table) {
 
-      let address = this.calculator.ResolveAddress(reference, this.grid.active_sheet);
+      let address = this.model.ResolveAddress(reference, this.grid.active_sheet);
 
       if (!IsCellAddress(address)) {
         address = address.start;
@@ -4044,6 +4377,11 @@ export class EmbeddedSpreadsheet {
 
             this.InflateAnnotations();
 
+            // and conditional formats
+
+            this.calculator.UpdateConditionals();
+            this.ApplyConditionalFormats(this.grid.active_sheet, false);
+            
           }
           else {
             return reject('unknown error (missing data)');
@@ -4164,6 +4502,9 @@ export class EmbeddedSpreadsheet {
 
     this.UpdateAnnotations();
 
+    this.calculator.UpdateConditionals();
+    this.ApplyConditionalFormats(event.activate, true);
+
   }
 
   protected HandleDrag(event: DragEvent): void {
@@ -4556,7 +4897,7 @@ export class EmbeddedSpreadsheet {
   protected UpdateAnnotations(): void {
     for (const annotation of this.grid.active_sheet.annotations) {
       if (annotation.temp.vertex) {
-        const vertex = annotation.temp.vertex as LeafVertex;
+        const vertex = annotation.temp.vertex as StateLeafVertex;
         if (vertex.state_id !== annotation.temp.state) {
           annotation.temp.state = vertex.state_id;
 
@@ -4703,7 +5044,7 @@ export class EmbeddedSpreadsheet {
 
                 this.parser.Walk(parse_result.expression, (unit) => {
                   if (unit.type === 'address' || unit.type === 'range') {
-                    this.calculator.ResolveSheetID(unit, undefined, this.grid.active_sheet);
+                    this.model.ResolveSheetID(unit, undefined, this.grid.active_sheet);
                   }
                   return true;
                 });
@@ -5436,35 +5777,5 @@ export class EmbeddedSpreadsheet {
     }
   }
 
-  /**
-   * this is only used in one place, can we just inline?
-   * [A: seems like it might be useful, though]
-   * 
-   * @param id 
-   * @param quote 
-   * @returns 
-   */
-  protected ResolveSheetName(id: number, quote = false): string | undefined {
-    const sheet = this.model.sheets.Find(id);
-    if (sheet) {
-      if (quote && QuotedSheetNameRegex.test(sheet.name)) {
-        return `'${sheet.name}'`;
-      }
-      return sheet.name;
-    }
-
-    /*
-    for (const sheet of this.grid.model.sheets) {
-      if (sheet.id === id) {
-        if (quote && QuotedSheetNameRegex.test(sheet.name)) {
-          return `'${sheet.name}'`;
-        }
-        return sheet.name;
-      }
-    }
-    */
-
-    return undefined;
-  }
 
 }