@trebco/treb 27.5.3 → 27.9.0

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

@@ -80,13 +80,15 @@ import { TileRange } from '../layout/base_layout';
 import { GridLayout } from '../layout/grid_layout';
 
 import type { GridSelection } from './grid_selection';
-import { OverlayEditor, OverlayEditorResult } from '../editors/overlay_editor';
+import { OverlayEditor } from '../editors/overlay_editor';
 
 import { TileRenderer } from '../render/tile_renderer';
 import type { GridEvent } from './grid_events';
 import { ErrorCode } from './grid_events';
 import type { LegacySerializedSheet } from './sheet_types';
+// import { FormulaBar } from '../editors/formula_bar';
 import { FormulaBar } from '../editors/formula_bar';
+
 import type { GridOptions } from './grid_options';
 import { BorderConstants } from './border_constants';
 import type { SerializeOptions } from './serialize_options';
@@ -114,7 +116,8 @@ import { GridBase } from './grid_base';
 import type { SetRangeOptions } from './set_range_options';
 import type { ClipboardCellData } from './clipboard_data';
 
-import type { ExternalEditorType } from './external_editor';
+import type { ExternalEditorConfig } from './external_editor_config';
+import { ExternalEditor } from '../editors/external_editor';
 
 interface DoubleClickData {
   timeout?: number;
@@ -148,7 +151,7 @@ export class Grid extends GridBase {
       this.UpdateAnnotationLayout();
       this.layout.UpdateAnnotation(this.active_sheet.annotations);
       this.layout.ApplyTheme(this.theme);
-      this.overlay_editor?.UpdateTheme(value);
+      this.overlay_editor?.UpdateScale(value);
       this.tab_bar?.UpdateScale(value);
   
       this.grid_events.Publish({
@@ -264,14 +267,18 @@ export class Grid extends GridBase {
 
   private RESIZE_PIXEL_BUFFER = 5;
 
-  private select_argument = false; // temp, WIP
+  /**
+   * formalizing the concept of external selection to support outside tooling.
+   * 
+   * FIXME: stop testing on this field. we need a better way to figure out
+   * if the external editor is active.
+   */
+  private external_editor_config?: Partial<ExternalEditorConfig>;
 
   /**
-   * not sure what select_argument was for (possibly outside client), but
-   * we're formalizing the concept of external selection to support outside
-   * tooling.
+   * support for external editor. created on demand.
    */
-  private external_editor: Partial<ExternalEditorType> | undefined;
+  private external_editor?: ExternalEditor;
 
   /**
    * flag indicating we're resizing, or hovering over a resize.
@@ -357,12 +364,11 @@ export class Grid extends GridBase {
    */
   constructor(
     options: GridOptions = {}, 
-    parser: Parser,
     model: DataModel,
     theme: Theme = DefaultTheme,
     initialze_dom = true ) {
 
-    super(options, parser, model);  
+    super(options, model);  
 
     this.decimal_separator_code = Localization.decimal_separator.charCodeAt(0);
 
@@ -1234,7 +1240,7 @@ export class Grid extends GridBase {
       this.UpdateLayout(); // in case we have changed font size
       // this.selection_renderer.Flush();
 
-      this.overlay_editor?.UpdateTheme(this.layout.scale);
+      this.overlay_editor?.UpdateScale(this.layout.scale);
 
       // if (this.formula_bar) this.formula_bar.UpdateTheme();
 
@@ -1659,21 +1665,48 @@ export class Grid extends GridBase {
    * want to have to use a duplicate internal field, it's clumsy and this
    * class isn't public-facing so it's not super important.
    */
-  public ExternalEditor(external_editor: Partial<ExternalEditorType>|undefined) {
+  public ExternalEditor(config: Partial<ExternalEditorConfig>|undefined) {
+
+    this.external_editor_config = config;
+
+    if (config) {
 
-    this.external_editor = external_editor;
+      const areas: Area[] = (config.dependencies || []).filter(
+        <T>(test: T|undefined): test is T => !!test).map(reference => 
+          IsCellAddress(reference) ? new Area(reference) : new Area(reference.start, reference.end));
 
-    if (external_editor) {
-      if (external_editor.dependencies) {
+      if (config.nodes?.length) {
 
-        // FIXME: this is getting messy and we're doing it twice, consolidate
+        if (!this.external_editor) {
+          const editor = new ExternalEditor(this.model, this.view);
+          this.external_editor = editor;
 
-        this.HighlightDependencies(external_editor.dependencies.filter(
-          <T>(entry: T|undefined): entry is T => !!entry).map(reference => 
-            IsCellAddress(reference) ? new Area(reference) : new Area(reference.start, reference.end)));
+          // should this persist, or should we only subscribe when we're active? (...)
+          // in theory, at least, it won't send any events unless something changes
+
+          editor.Subscribe(event => this.HighlightDependencies(editor.dependencies));
+        }
+
+        this.external_editor.AttachNodes(config.nodes, config.assume_formula ?? true);
+ 
       }
+      else {
+        if (this.external_editor) {
+          this.external_editor.Reset();
+        }
+      }
+
+      if (config.dependencies) {
+        this.HighlightDependencies(areas);
+      }
+
     }
     else {
+
+      if (this.external_editor) {
+        this.external_editor.Reset();
+      }
+
       this.ClearAdditionalSelections();
       this.RenderSelections(true);
     }
@@ -1687,15 +1720,16 @@ export class Grid extends GridBase {
     this.RenderSelections();
   }
 
-  /**
+  /* *
    * FIXME: who uses this? anyone?
-   */
+   * /
   public GetNumberFormat(address: ICellAddress): string|undefined {
     const style = this.active_sheet.CellStyleData(address);
     if (style && style.number_format) {
       return NumberFormatCache.Get(style.number_format).toString();
     }
   }
+  */
 
   /**
    * I can't figure out a way in typescript to overload the GetRange function 
@@ -1953,7 +1987,7 @@ export class Grid extends GridBase {
   }
 
   /** repaint after an external event (calculation) */
-  public Update(force = false, area?: Area): void {
+  public Update(force = false, area?: IArea|IArea[]): void {
     this.DelayedRender(force, area);
   }
 
@@ -2534,8 +2568,8 @@ export class Grid extends GridBase {
 
     this.formula_bar = new FormulaBar(
       grid_container,
-      this.parser,
-      this.theme,
+      // this.parser,
+      // this.theme,
       this.model,
       this.view,
       this.options, autocomplete);
@@ -2711,13 +2745,12 @@ export class Grid extends GridBase {
 
     this.overlay_editor = new OverlayEditor(
         this.container,
-        this.parser,
         this.theme,
         this.model,
         this.view,
         autocomplete);
 
-    this.overlay_editor.UpdateTheme(this.layout.scale);
+    this.overlay_editor.UpdateScale(this.layout.scale);
     this.overlay_editor.autocomplete_matcher = this.autocomplete_matcher;
 
     this.overlay_editor.Subscribe(event => {
@@ -2745,7 +2778,11 @@ export class Grid extends GridBase {
           break;
 
         case 'end-selection':
+        case 'reset-selection':
           this.ClearSelection(this.active_selection);
+          if (this.overlay_editor?.target_address?.sheet_id && this.active_sheet.id !== this.overlay_editor.target_address.sheet_id) {
+            this.ActivateSheetID(this.overlay_editor.target_address.sheet_id);
+          }
           this.DelayedRender();
           break;
 
@@ -2756,9 +2793,7 @@ export class Grid extends GridBase {
 
   }
 
-
-
-  private DelayedRender(force = false, area?: Area, full_tile = false) {
+  private DelayedRender(force = false, area?: IArea|IArea[], full_tile = false) {
 
     // if area is passed, set dirty before calling repaint
 
@@ -3732,7 +3767,7 @@ export class Grid extends GridBase {
       this.ClearAdditionalSelections();
     }
 
-    if (!selecting_argument || !this.formula_bar?.selecting) {
+    if (!selecting_argument || (!this.formula_bar?.selecting && !this.external_editor?.selecting)) {
 
       // not sure why this breaks the formula bar handler
 
@@ -4021,11 +4056,19 @@ export class Grid extends GridBase {
         if (this.overlay_editor?.editing) {
           // ...
         }
-        else if (this.external_editor) {
-          // ...
-        }
-        else if (this.select_argument) {
-          // ...
+        else if (this.external_editor_config) {
+
+          // there are two possible cases: either an update function
+          // or a full-on editor. we should probably test for both?
+
+          if (this.external_editor?.active) {
+            this.external_editor.FocusEditor();
+          }
+          if (this.external_editor_config.update) {
+            // not necessary?
+            // console.info('call update?');
+          }
+
         }
         else if (this.formula_bar) {
           this.formula_bar.FocusEditor();
@@ -4289,7 +4332,7 @@ export class Grid extends GridBase {
         label = Area.CellAddressToLabel(data.merge_area.start);
       }
 
-      if (this.external_editor || this.active_sheet.id !== this.editing_cell.sheet_id) {
+      if (this.external_editor_config || this.active_sheet.id !== this.editing_cell.sheet_id) {
         const name = this.active_sheet.name;
 
         if (QuotedSheetNameRegex.test(name)) {
@@ -4311,9 +4354,15 @@ export class Grid extends GridBase {
     else if (this.formula_bar && this.formula_bar.selecting) {
       this.formula_bar.InsertReference(label, 0);
     }
-    else if (this.external_editor) {
-      if (this.external_editor.update) {
-        const result = this.external_editor.update.call(0, label);
+    else if (this.external_editor_config) {
+
+      if (this.external_editor?.active) {
+        this.external_editor.FocusEditor();
+        this.external_editor.InsertReference(label, 0);
+      }
+
+      if (this.external_editor_config.update) {
+        const result = this.external_editor_config.update.call(0, label);
         if (result && Array.isArray(result)) {
           this.HighlightDependencies(
             result.filter(<T>(entry: T|undefined): entry is T => !!entry).map(reference => 
@@ -4321,12 +4370,14 @@ export class Grid extends GridBase {
         }
       }
     }
+    /*
     else if (this.select_argument) {
       this.grid_events.Publish({
         type: 'alternate-selection',
         selection: this.active_selection,
       });
     }
+    */
   }
 
   /**
@@ -4335,11 +4386,11 @@ export class Grid extends GridBase {
    *
    * FIXME: why is this not an accessor?
    */
-  private SelectingArgument() {
+  private SelectingArgument(): boolean {
     return (this.overlay_editor?.editing && this.overlay_editor?.selecting)
       || (this.formula_bar && this.formula_bar.selecting)
-      || (this.external_editor)
-      || (this.select_argument);
+      || (!!this.external_editor_config);
+      // || (this.select_argument);
   }
 
   /**
@@ -4371,16 +4422,16 @@ export class Grid extends GridBase {
       editor_open = true;
       const result = this.overlay_editor.HandleKeyDown(event);
       switch (result) {
-        case OverlayEditorResult.handled:
+        case 'handled':
           return;
 
-        case OverlayEditorResult.discard:
+        case 'discard':
           this.editing_state = EditingState.NotEditing;
           this.DismissEditor();
           this.DelayedRender();
           return;
 
-        case OverlayEditorResult.commit:
+        case 'commit':
 
           // FIXME: unify this (to the extent possible) w/ the other editor
 

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

@@ -40,7 +40,7 @@ import type { DataModel, MacroFunction, SerializedModel, SerializedNamedExpressi
 import type { Parser, UnitAddress} from 'treb-parser';
 import { type ExpressionUnit, IllegalSheetNameRegex, ParseCSV, ArgumentSeparatorType, DecimalMarkType } from 'treb-parser';
 import { Area, IsCellAddress, ValidationType, ValueType, DefaultTableSortOptions } from 'treb-base-types';
-import type { ICellAddress, IArea, Cell, CellValue , Style, CellStyle, Table, TableSortOptions, TableTheme, Complex } from 'treb-base-types';
+import type { ICellAddress, IArea, Cell, CellValue , Style, CellStyle, Table, TableSortOptions, TableTheme, Complex, PatchOptions as PatchAreaOptions } from 'treb-base-types';
 import { Sheet } from './sheet';
 import type { FunctionDescriptor} from '../editors/autocomplete_matcher';
 import { AutocompleteMatcher, DescriptorType } from '../editors/autocomplete_matcher';
@@ -61,6 +61,11 @@ import type { UpdateFlags } from './update_flags';
 import type { FreezePane, LegacySerializedSheet } from './sheet_types';
 import type { Annotation } from './annotation';
 import type { ClipboardCellData } from './clipboard_data';
+import type { ConditionalFormat } from './conditional_format';
+
+interface PatchOptions extends PatchAreaOptions {
+  sheet: Sheet;
+}
 
 export class GridBase {
 
@@ -132,7 +137,6 @@ export class GridBase {
 
   constructor(
     options: GridOptions = {},
-    parser: Parser,
     model: DataModel) {
 
     this.model = model;
@@ -144,7 +148,7 @@ export class GridBase {
 
     // shared parser
 
-    this.parser = parser;
+    this.parser = model.parser;
 
     // apply default options, meaning that you need to explicitly set/unset
     // in order to change behavior. FIXME: this is ok for flat structure, but
@@ -2147,6 +2151,29 @@ export class GridBase {
 
   }
 
+  protected PatchExpressionSheetName(expression: string, old_name: string, name: string): string|undefined {
+
+    let modified = false;
+    const parsed = this.parser.Parse(expression || '');
+    if (parsed.expression) {
+      this.parser.Walk(parsed.expression, (element: ExpressionUnit) => {
+        if (element.type === 'address') {
+          if (element.sheet && element.sheet.toLowerCase() === old_name) {
+            element.sheet = name;
+            modified = true;
+          }
+        }
+        return true; // continue walk
+      });
+      if (modified) {
+        return '=' + this.parser.Render(parsed.expression, { missing: '' });
+      }
+    }
+
+    return undefined;
+
+  }
+
   /**
    * splitting this logic into a new function so we can reuse it 
    * for invalidating broken references. generally we'll call this
@@ -2166,45 +2193,39 @@ export class GridBase {
       // cells
       sheet.cells.IterateAll((cell: Cell) => {
         if (cell.ValueIsFormula()) {
-          let modified = false;
-          const parsed = this.parser.Parse(cell.value || '');
-          if (parsed.expression) {
-            this.parser.Walk(parsed.expression, (element: ExpressionUnit) => {
-              if (element.type === 'address') {
-                if (element.sheet && element.sheet.toLowerCase() === old_name) {
-                  element.sheet = name;
-                  modified = true;
+          const updated = this.PatchExpressionSheetName(cell.value||'', old_name, name);
+          if (updated) {
+            cell.value = updated;
+            changes++;
+          }          
+        }
+      });
+
+      // conditionals
+      if (sheet.conditional_formats?.length) {
+        for (const format of sheet.conditional_formats) {
+          switch (format.type) {
+            case 'cell-match':
+            case 'expression':
+              {
+                const updated = this.PatchExpressionSheetName(format.expression, old_name, name);
+                if (updated) {
+                  format.expression = updated;
+                  changes++;
                 }
               }
-              return true; // continue walk
-            });
-            if (modified) {
-              cell.value = '=' + this.parser.Render(parsed.expression, { missing: '' });
-              changes++;
-            }
+              break;
           }
         }
-      });
+      }
 
       // annotations
       for (const annotation of sheet.annotations) {
         if (annotation.data.formula) {
-          let modified = false;
-          const parsed = this.parser.Parse(annotation.data.formula || '');
-          if (parsed.expression) {
-            this.parser.Walk(parsed.expression, (element: ExpressionUnit) => {
-              if (element.type === 'address') {
-                if (element.sheet && element.sheet.toLowerCase() === old_name) {
-                  element.sheet = name;
-                  modified = true;
-                }
-              }
-              return true; // continue walk
-            });
-            if (modified) {
-              annotation.data.formula = '=' + this.parser.Render(parsed.expression, { missing: '' });
-              changes++;
-            }
+          const updated = this.PatchExpressionSheetName(annotation.data.formula, old_name, name);
+          if (updated) {
+            annotation.data.formula = updated;
+            changes++;
           }
         }
       }
@@ -2635,7 +2656,121 @@ export class GridBase {
 
   }
 
-  
+  /**
+   * patch an expression for insert/delete row/column operations.
+   * FIXME: should move, maybe to parser? (...)
+   * 
+   * NOTE: did I write this twice? we only need one. check which one is better.
+   * @see PatchFormulasInternal
+   * 
+   * @returns the updated expression, or `undefined` if no changes were made.
+   */
+  protected PatchExpression(expression: string, options: PatchOptions) { 
+
+    let count = 0;
+    const parse_result = this.parser.Parse(expression);
+    if (parse_result.expression) {
+
+      this.parser.Walk(parse_result.expression, unit => {
+        if (unit.type === 'range') {
+          if (!unit.start.sheet || (unit.start.sheet.toLowerCase() === options.sheet.name.toLowerCase())) {
+            const updated = Area.PatchArea(unit, options);
+            if (updated) {
+              unit.start.row = updated.start.row;
+              unit.start.column = updated.start.column;
+              unit.end.row = updated.end.row;
+              unit.end.column = updated.end.column;
+            }
+            else {
+
+              // FIXME: maybe have options for this? we don't really have a 
+              // good way to replace nodes atm
+              unit.start.row = unit.end.row = unit.start.column = unit.end.column = -1;
+
+            }
+          }
+          count++;
+          return false;
+        }
+        else if (unit.type === 'address') {
+          const updated = Area.PatchArea({start: unit, end: unit}, options);
+          if (updated) {
+            unit.row = updated.start.row;
+            unit.column = updated.start.column;
+          }
+          else {
+
+            // see above
+            unit.row = unit.column = -1;
+          }
+          count++;
+          return false;
+        }
+        return true;
+      });
+
+      if (count) {
+        const rendered = this.parser.Render(parse_result.expression, {
+          missing: '',
+        });
+        // console.info("FROM", expression, "TO", rendered);
+        return rendered;
+      }
+
+    }
+
+    return undefined;
+
+  }
+
+  /**
+   * patch sheet conditionals for insert/delete row/column operations.
+   * some of them may be deleted.
+   */
+  protected PatchConditionals(options: PatchOptions) {
+
+    if (options.sheet.conditional_formats?.length) {
+
+      const delete_list: Set<ConditionalFormat> = new Set();
+      for (const format of options.sheet.conditional_formats) {
+
+        // first adjust the format area 
+
+        const updated = Area.PatchArea(format.area, options);
+        if (updated) {
+          format.area = JSON.parse(JSON.stringify(updated));
+        }
+        else {
+          delete_list.add(format);
+          continue; // don't bother with formula
+        }
+
+        // next update the formula, if necessary. what do we do if the
+        // area has disappeared? should be a #REF error, not sure we 
+        // can encode that properly
+
+        switch (format.type) {
+          case 'expression':
+          case 'cell-match':
+            {
+              const updated = this.PatchExpression(format.expression, options);
+
+              if (updated) {
+                format.expression = updated;
+              }
+            }
+            break;
+        }
+
+      }
+
+      if (delete_list.size) {
+        options.sheet.conditional_formats = options.sheet.conditional_formats.filter(test => !delete_list.has(test));
+      }
+
+    }
+
+  }
 
   /**
    * FIXME: should be API method
@@ -2665,6 +2800,15 @@ export class GridBase {
       return { error: true };
     }
 
+    // conditionals
+    this.PatchConditionals({
+        sheet: target_sheet, 
+        before_column: 0, 
+        column_count: 0, 
+        before_row: command.before_row, 
+        row_count: command.count
+      });
+
     // see InsertColumnsInternal re: tables. rows are less complicated,
     // except that if you delete the header row we want to remove the 
     // table entirely.
@@ -2979,6 +3123,14 @@ export class GridBase {
       return { error: true };
     }
     
+    // conditionals
+    this.PatchConditionals({
+      sheet: target_sheet, 
+      before_column: command.before_column, 
+      column_count: command.count, 
+      before_row: 0, 
+      row_count: 0 });
+
     // patch tables. we removed this from the sheet routine entirely,
     // we need to rebuild any affected tables now.
 

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

@@ -137,7 +137,7 @@ export class ScaleControl extends EventSource<ScaleEvent> {
 
     });
 
-    this.slider = DOM.Create<HTMLInputElement>('input', undefined, popup, undefined, {
+    this.slider = DOM.Create('input', undefined, popup, undefined, {
       type: 'range',
       min: '50',
       max: '200',