@trebco/treb 28.17.4 → 29.1.2

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

@@ -48,9 +48,7 @@ import {
   TextPartFlag,
 } from 'treb-base-types';
 
-import type {
-  Parser, 
-  ExpressionUnit} from 'treb-parser';
+import type { ExpressionUnit } from 'treb-parser';
 import { 
   DecimalMarkType, 
   ArgumentSeparatorType, 
@@ -66,7 +64,6 @@ import { SelectionRenderer } from '../render/selection-renderer';
 import { TabBar } from './tab_bar';
 import type { StatsEntry } from './tab_bar';
 
-import { Sheet } from './sheet';
 import { MockLayout } from '../layout/mock-layout';
 import type { BaseLayout } from '../layout/base_layout';
 import { TileRange } from '../layout/base_layout';
@@ -79,21 +76,24 @@ import { TileRange } from '../layout/base_layout';
 
 import { GridLayout } from '../layout/grid_layout';
 
-import type { GridSelection } from './grid_selection';
 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 { 
+  CompositeNamed,
+  DataModel, 
+  GridSelection,
+  LegacySerializedSheet, 
+} from 'treb-data-model';
+import { Annotation, type AnnotationData, Sheet } from 'treb-data-model';
+
+import { FormulaBar } from '../editors/formula_bar';
 import type { GridOptions } from './grid_options';
 import { BorderConstants } from './border_constants';
-import type { SerializeOptions } from './serialize_options';
 import { UA } from '../util/ua';
-import { Annotation, type AnnotationData } from './annotation';
 import { Autocomplete } from '../editors/autocomplete';
 
 import { MouseDrag } from './drag_mask';
@@ -109,8 +109,6 @@ import type {
 import { CommandKey
 } from './grid_command';
 
-import type { DataModel, SerializedModel } from './data_model';
-
 import { DOMContext } from 'treb-base-types';
 import { GridBase } from './grid_base';
 import type { SetRangeOptions } from './set_range_options';
@@ -891,7 +889,8 @@ export class Grid extends GridBase {
   public FromImportData(
     import_data: {
       sheets: ImportedSheetData[],
-      names?: Record<string, string|number>,
+      // names?: Record<string, string|number>,
+      named?: CompositeNamed[],
       active_tab?: number,
     },
     render = false,
@@ -969,14 +968,26 @@ export class Grid extends GridBase {
     }
 
     this.model.sheets.UpdateIndexes();
-    this.model.named_ranges.Reset();
-    this.model.named_expressions.clear();
 
+    this.model.named.Reset();
+    // this.model.named_ranges.Reset();
+    // this.model.named_expressions.clear();
+
+    console.info({IDX: import_data.named});
+
+    if (import_data.named) {
+      this.model.UnserializeComposite(import_data.named, this.active_sheet);
+    }
+
+    /*
     if (import_data.names) {
       
+      console.info("IDN", { names: import_data.names })
+
       for (const name of Object.keys(import_data.names)) {
 
-        const validated = this.model.named_ranges.ValidateNamed(name);
+        const validated = this.model.named.ValidateNamed(name);
+
         if (!validated) {
           console.warn(`invalid name: ${name}`, import_data.names[name]);
           continue;
@@ -994,14 +1005,14 @@ export class Grid extends GridBase {
               const sheet_id = name_map[parse_result.expression.start.sheet || ''];
               if (sheet_id) {
                 parse_result.expression.start.sheet_id = sheet_id;
-                this.model.named_ranges.SetName(validated, new Area(parse_result.expression.start, parse_result.expression.end), false);
+                this.model.named.SetNamedRange(validated, new Area(parse_result.expression.start, parse_result.expression.end));
               }
             }
             else if (parse_result.expression.type === 'address') {
               const sheet_id = name_map[parse_result.expression.sheet || ''];
               if (sheet_id) {
                 parse_result.expression.sheet_id = sheet_id;
-                this.model.named_ranges.SetName(validated, new Area(parse_result.expression), false);
+                this.model.named.SetNamedRange(validated, new Area(parse_result.expression));
               }
             }
             else {
@@ -1022,13 +1033,16 @@ export class Grid extends GridBase {
                 }
                 return true;
               });
-              this.model.named_expressions.set(validated, expr);
+
+              this.model.named.SetNamedExpression(validated, expr);
+
             }
           }
         }
       }
-      this.model.named_ranges.RebuildList();
+      // this.model.named_ranges.RebuildList();
     }
+    */
 
     // FIXME: do we need to rebuild autocomplete here (A: yes)
     // ...
@@ -1190,6 +1204,15 @@ export class Grid extends GridBase {
     this.Repaint(true);
   }
 
+  /**
+   * we need this method for split views
+   */
+  public UpdateTabBar(): void {
+    if (this.tab_bar) {
+      this.tab_bar.Update();
+    }
+  }
+
   /**
    * @param initial first call, from the grid Initialize() method
    */
@@ -1563,52 +1586,50 @@ export class Grid extends GridBase {
   }
 
   /**
-   * set or clear name
+   * set or clear name. optionally overwrite existing name. note that
+   * you cannot overwrite function names, only existing named ranges/expressions.
+   * 
+   * set name to refer to a range (named range) or expression/value (named 
+   * expression). range has priority if you set both (FIXME: make that impossible)
+   * 
+   * note that expression here must be a valid expression in SL. if you want 
+   * to set a literal string, enclose it in double quotes (as you would when 
+   * using a string as an argument to a function).
    */
-  public SetName(name: string, range?: ICellAddress | Area, expression?: string): void {
+  public SetName(name: string, range?: ICellAddress | Area, expression?: string, scope?: number, overwrite = false): void {
 
-    // console.info('setname', name, range, expression);
+    // console.info('setname', name, range, expression, scope, overwrite);
 
     // validate/translate name first
 
-    const validated = this.model.named_ranges.ValidateNamed(name);
+    const validated = this.model.named.ValidateNamed(name);
 
     if (!validated) {
       throw new Error('invalid name');
     }
 
-    // check against functions
+    name = validated;
 
-    // console.info('checking...', name, this.autocomplete_matcher?.function_map);
+    // check against functions. also an error if the name exists
+    // but the overwrite flag is not set.
 
-    const compare = name.trim().toUpperCase();
     if (this.autocomplete_matcher) {
-      for (const name of Object.keys(this.autocomplete_matcher.function_map)) {
-        if (compare === name.toUpperCase()) {
-          // const descriptor = this.autocomplete_matcher.function_map[name];
-
-          // hmmm... we're not actually setting this type 
-          // (DescriptorType.Function). it seems like we only 
-          // set the _other_ type. sloppy.
 
+      const ac_entry = this.autocomplete_matcher.Get(name);
+      if (ac_entry) {
+        if (!ac_entry.named || !overwrite) {
           if (range || expression) {
             throw new Error('name already defined');
           }
-
-          //if (descriptor.type !== DescriptorType.Token) {
-          //  throw new Error('invalid name');
-          //}
-
-          break; // since we can't have two with the same name
         }
       }
-    }
-    
-    name = validated;
 
+    }
+        
     const command: SetNameCommand = {
       key: CommandKey.SetName,
       name,
+      scope,
     };
    
     if (range) {
@@ -1629,7 +1650,19 @@ export class Grid extends GridBase {
 
     }
     else if (expression) {
+
       const parse_result = this.parser.Parse(expression);
+      
+      // there's a case we're missing here: if you pass a literal
+      // string, not as a function, that should be interpreted as 
+      // a string. we still want to use the parser on functions 
+      // and literal types... how to distinguish?
+
+      // actually, check that: let's require strings to be quoted,
+      // so they get interpreted as literals. if you want to do fancy
+      // switching do that at a higher level.
+
+      // ...
 
       // resolve sheet. otherwise we wind up with dangling
       // references. NOTE: need to do this on import as well
@@ -1700,7 +1733,7 @@ export class Grid extends GridBase {
           // 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));
+          editor.Subscribe(() => this.HighlightDependencies(editor.dependencies));
         }
 
         this.external_editor.AttachNodes(config.nodes, config.assume_formula ?? true);
@@ -2564,7 +2597,10 @@ export class Grid extends GridBase {
 
           case 'identifier':
             {
-              target_area = this.model.named_ranges.Get(parse_result.expression.name);
+              const named = this.model.GetName(parse_result.expression.name, this.active_sheet.id); // assuming it's in the active sheet? what if it's qualified?
+              if (named?.type === 'range') {
+                target_area = named.area;
+              }
               if (!target_area) {
                 if (!this.primary_selection.empty) {
                   this.SetName(parse_result.expression.name.toUpperCase(), this.primary_selection.area);
@@ -3886,7 +3922,7 @@ export class Grid extends GridBase {
               type: 'cell-event',
               data: {
                 type: 'hyperlink',
-                data: link,
+                reference: link,
               }
             });
           });
@@ -3939,17 +3975,6 @@ export class Grid extends GridBase {
 
           }
 
-          /*
-          if (result.event) {
-            Yield().then(() => {
-              this.grid_events.Publish({
-                type: 'cell-event',
-                data: result.event,
-              });
-            });
-          }
-          */
-
           return;
         }
       }
@@ -3977,7 +4002,7 @@ export class Grid extends GridBase {
         y: move_event.offsetY - offset.y,
       };
       const testpoint = grid_rect.Clamp(point.x, point.y);
-      const address = this.layout.PointToAddress_Grid(testpoint, true);
+      const address = this.layout.PointToAddress_Grid(testpoint);
 
       const scroll_node = this.layout.scroll_reference_node;
 
@@ -4349,7 +4374,7 @@ export class Grid extends GridBase {
     const data = this.active_sheet.CellData(selection.area.start);
     const target = new Area(data.merge_area ? data.merge_area.start : selection.target);
 
-    let label = this.model.named_ranges.MatchSelection(selection.area, target);
+    let label = this.model.named.MatchSelection(selection.area, target);
 
     if (!label) {
 
@@ -4375,16 +4400,16 @@ export class Grid extends GridBase {
     // for now, we might update that in the future.
 
     if (this.overlay_editor?.editing && this.overlay_editor.selecting) {
-      this.overlay_editor.InsertReference(label, 0);
+      this.overlay_editor.InsertReference(label);
     }
     else if (this.formula_bar && this.formula_bar.selecting) {
-      this.formula_bar.InsertReference(label, 0);
+      this.formula_bar.InsertReference(label);
     }
     else if (this.external_editor_config) {
 
       if (this.external_editor?.active) {
         this.external_editor.FocusEditor();
-        this.external_editor.InsertReference(label, 0);
+        this.external_editor.InsertReference(label);
       }
 
       if (this.external_editor_config.update) {
@@ -5338,8 +5363,11 @@ export class Grid extends GridBase {
             break;
 
           case 'identifier':
-            if (this.model.named_ranges.Get(unit.name)) {
-              unit.name = unit.name.toUpperCase();
+            {
+              const named_range = this.model.GetName(unit.name, this.active_sheet.id); // FIXME: is this the correct sheet ref?
+              if (named_range?.type === 'range') {
+                unit.name = unit.name.toUpperCase();
+              }
             }
             break;
 
@@ -6133,6 +6161,7 @@ export class Grid extends GridBase {
       // be a rectangle) and one of those new cells might itself be merged.
       // so we need to iterate. there's a lot of duplication here, though.
 
+      // eslint-disable-next-line no-constant-condition
       recheck_loop: while (true) {
         for (const cell of this.active_sheet.cells.Iterate(real_area, false)) {
           if (cell.merge_area && !real_area.ContainsArea(cell.merge_area)) {
@@ -6420,8 +6449,8 @@ export class Grid extends GridBase {
       const target = new Area(data.merge_area ? data.merge_area.start : selection.target);
 
       this.formula_bar.label = 
-      this.model.named_ranges.MatchSelection(selection.area, target)
-        || Area.CellAddressToLabel(target.start);
+        this.model.named.MatchSelection(selection.area, target)
+          || Area.CellAddressToLabel(target.start);
 
     }
 

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

@@ -36,21 +36,24 @@
  */
 
 import { EventSource } from 'treb-utils';
-import type { DataModel, MacroFunction, SerializedModel, SerializedNamedExpression, ViewModel } from './data_model';
+import type { DataModel, ConditionalFormat, // MacroFunction, SerializedModel, SerializedNamedExpression, 
+              ViewModel } from 'treb-data-model';
+
 import type { Parser, UnitAddress} from 'treb-parser';
-import { type ExpressionUnit, IllegalSheetNameRegex, ParseCSV, ArgumentSeparatorType, DecimalMarkType } from 'treb-parser';
+import { type ExpressionUnit, IllegalSheetNameRegex, ParseCSV, 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, PatchOptions as PatchAreaOptions } from 'treb-base-types';
-import { Sheet } from './sheet';
+import type { ICellAddress, IArea, Cell, CellValue, CellStyle, Table, TableSortOptions, TableTheme, Complex, PatchOptions as PatchAreaOptions } from 'treb-base-types';
+
+import { Sheet, type SerializeOptions, type Annotation } from 'treb-data-model';
+
 import type { FunctionDescriptor} from '../editors/autocomplete_matcher';
-import { AutocompleteMatcher, DescriptorType } from '../editors/autocomplete_matcher';
+import { AutocompleteMatcher } from '../editors/autocomplete_matcher';
 import { NumberFormat, ValueParser } from 'treb-format';
 
 import type { GridEvent } from './grid_events';
 import { ErrorCode } from './grid_events';
 import type { CommandRecord, DataValidationCommand, DuplicateSheetCommand, FreezeCommand, InsertColumnsCommand, InsertRowsCommand, ResizeColumnsCommand, ResizeRowsCommand, SelectCommand, SetRangeCommand, ShowSheetCommand, SortTableCommand } from './grid_command';
 import { DefaultGridOptions, type GridOptions } from './grid_options';
-import type { SerializeOptions } from './serialize_options';
 
 import { BorderConstants } from './border_constants';
 
@@ -58,15 +61,18 @@ import { CommandKey } from './grid_command';
 import type { Command, ActivateSheetCommand, 
                DeleteSheetCommand, UpdateBordersCommand, SheetSelection } from './grid_command';
 import type { UpdateFlags } from './update_flags';
-import type { FreezePane, LegacySerializedSheet } from './sheet_types';
-import type { Annotation } from './annotation';
+import type { FreezePane, LegacySerializedSheet } from 'treb-data-model';
 import type { ClipboardCellData } from './clipboard_data';
-import type { ConditionalFormat } from './conditional_format';
 
 interface PatchOptions extends PatchAreaOptions {
   sheet: Sheet;
 }
 
+// this is an assert, bascially, for completeness. we could probably
+// resolve the eslint issue (there's no type option) but not sure it's
+// useful to do so
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const AssertNever = (value: never) => {
   console.error('invalid case');
 };
@@ -666,6 +672,7 @@ export class GridBase {
    *
    * this is non-UI; specialization should handle the UI part
    */
+   // eslint-disable-next-line @typescript-eslint/no-unused-vars
    public UpdateSheets(data: LegacySerializedSheet[], render = false, activate_sheet?: number | string): void {
 
     Sheet.Reset(); // reset ID generation
@@ -719,24 +726,43 @@ export class GridBase {
    */
    public SetAutocompleteFunctions(functions: FunctionDescriptor[]): void {
 
-    // why does iterable support forEach but not map? 
-
     const expressions: FunctionDescriptor[] = [];
+
+    for (const entry of this.model.named.list) {
+      expressions.push({
+        name: entry.name,
+        named: true,
+        type: 'token',
+      });
+    }
+
+    /*
     for (const name of this.model.named_expressions.keys()) {
       expressions.push({
-        name, type: DescriptorType.Function,
+        name, 
+        named: true,
+        type: 'token',
       });
     }
+    */
 
+    const consolidated= functions.slice(0).concat(expressions);
+
+    /*
     const consolidated = functions.slice(0).concat(
       this.model.named_ranges.List().map((named_range) => {
-        return { name: named_range.name, type: DescriptorType.Token };
+        return { 
+          name: named_range.name, 
+          named: true,
+          type: 'token' 
+        };
       }),
       expressions,
     );
+    */
 
-    //this.autocomplete_matcher.SetFunctions(functions);
     this.autocomplete_matcher.SetFunctions(consolidated);
+
   }
 
   public ResetMetadata(): void {
@@ -813,8 +839,9 @@ export class GridBase {
 
     Sheet.Reset();
     this.UpdateSheets([], true);
-    this.model.named_ranges.Reset();
-    this.model.named_expressions.clear();
+    
+    this.model.named.Reset();
+    
     this.model.macro_functions.clear(); //  = {};
     this.model.tables.clear();
 
@@ -839,7 +866,7 @@ export class GridBase {
         return false;
       }
 
-      let valid = true;
+      // let valid = true;
 
       for (const cell of sheet.cells.Iterate(area)) {
 
@@ -885,9 +912,9 @@ export class GridBase {
       });
       */
 
-      if (!valid) {
-        return false;
-      }
+      // if (!valid) {
+      //  return false;
+      // }
 
     }
     return true;
@@ -985,7 +1012,7 @@ export class GridBase {
       if (i === command.index || sheet.id === command.id || sheet.name.toLowerCase() === named_sheet) {
         is_active = (sheet === this.active_sheet);
 
-        this.model.named_ranges.RemoveRangesForSheet(sheet.id);
+        this.model.named.RemoveRangesForSheet(sheet.id);
         target_name = sheet.name;
 
         index = i;
@@ -1917,6 +1944,7 @@ export class GridBase {
         // have to have a proper area. there's no case where we would
         // want to add it. so we only handle the area case.
 
+        // eslint-disable-next-line no-fallthrough
         case CommandKey.RemoveConditionalFormat:
 
           if (command.area) {
@@ -2515,7 +2543,7 @@ export class GridBase {
       return;
     }
 
-    let error = false;
+    // let error = false;
     area = sheet.RealArea(area); // collapse
 
     for (const cell of sheet.cells.Iterate(area)) {
@@ -2554,13 +2582,17 @@ export class GridBase {
       }
     }
     
+    /*
     if (error) {
       this.Error(ErrorCode.array); // `You can't change part of an array.`
     }
     else {
       sheet.ClearArea(area);
     }
-    
+    */
+
+    sheet.ClearArea(area);
+
   }
 
   /**
@@ -2678,6 +2710,7 @@ export class GridBase {
    * 
    * @param command 
    */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   protected SelectInternal(command: SelectCommand) {
     // does nothing
   }
@@ -2942,7 +2975,7 @@ export class GridBase {
     }
     
 
-    this.model.named_ranges.PatchNamedRanges(target_sheet.id, 0, 0, command.before_row, command.count);
+    this.model.named.PatchNamedRanges(target_sheet.id, 0, 0, command.before_row, command.count);
 
     const target_sheet_name = target_sheet.name.toLowerCase();
 
@@ -3284,7 +3317,7 @@ export class GridBase {
     }
 
 
-    this.model.named_ranges.PatchNamedRanges(target_sheet.id, command.before_column, command.count, 0, 0);
+    this.model.named.PatchNamedRanges(target_sheet.id, command.before_column, command.count, 0, 0);
 
     // FIXME: we need an event here? 
 
@@ -3929,7 +3962,7 @@ export class GridBase {
                 sheet.UpdateCellStyle(address, {
                   indent: Math.max(0, (style.indent || 0) + command.delta),
                 }, true);
-              };
+              }
             }
 
             if (sheet === this.active_sheet) {
@@ -4011,42 +4044,25 @@ export class GridBase {
           // FOR THE TIME BEING we're going to add that restriction to
           // the calling function, which (atm) is the only way to get here.
 
-          if (command.area) {
-
-            //if (this.model.named_expressions[command.name]) {
-            //  delete this.model.named_expressions[command.name];
-            //}
-            this.model.named_expressions.delete(command.name);
+          {
+            const ac_token: FunctionDescriptor = { type: 'token', named: true, name: command.name, scope: command.scope };
+            if (command.area || command.expression) {
+              if (command.area) {
+                this.model.named.SetNamedRange(command.name, new Area(command.area.start, command.area.end), command.scope);
+              }
+              else if (command.expression) {
+                this.model.named.SetNamedExpression(command.name, command.expression, command.scope);
+              }
+              this.autocomplete_matcher.AddFunctions(ac_token);
+            }
+            else {
+              this.model.named.ClearName(command.name, command.scope);
+              this.autocomplete_matcher.RemoveFunctions(ac_token);
+            }
 
-            this.model.named_ranges.SetName(command.name,
-              new Area(command.area.start, command.area.end));
-            this.autocomplete_matcher.AddFunctions({
-              type: DescriptorType.Token,
-              name: command.name,
-            });
-          }
-          else if (command.expression) {
-            this.model.named_ranges.ClearName(command.name);
-            this.model.named_expressions.set(command.name, command.expression);
-            this.autocomplete_matcher.AddFunctions({
-              type: DescriptorType.Token,
-              name: command.name,
-            });
-          }
-          else {
-            this.model.named_ranges.ClearName(command.name);
-            //if (this.model.named_expressions[command.name]) {
-            //  delete this.model.named_expressions[command.name];
-            //}
-            this.model.named_expressions.delete(command.name);
-
-            this.autocomplete_matcher.RemoveFunctions({
-              type: DescriptorType.Token,
-              name: command.name,
-            });
+            flags.structure_event = true;
+            flags.structure_rebuild_required = true;
           }
-          flags.structure_event = true;
-          flags.structure_rebuild_required = true;
           break;
 
         case CommandKey.UpdateBorders:

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

@@ -19,10 +19,10 @@
  * 
  */
 
-import type { ICellAddress, IArea, Style, CellStyle, Color, CellValue, Table, TableSortType, TableTheme } from 'treb-base-types';
+import type { ICellAddress, IArea, CellStyle, Color, CellValue, Table, TableSortType, TableTheme } from 'treb-base-types';
 import type { ExpressionUnit } from 'treb-parser';
 import type { BorderConstants } from './border_constants';
-import type { ConditionalFormat } from './conditional_format';
+import type { ConditionalFormat } from 'treb-data-model';
 
 /**
  * switching to an exec-command based model, so we can serialize
@@ -220,6 +220,7 @@ export interface SetNameCommand {
   name: string;
   area?: IArea;
   expression?: ExpressionUnit;
+  scope?: number;
 }
 
 export interface DataValidationCommand {

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

@@ -19,11 +19,8 @@
  * 
  */
 
-import type { GridSelection } from './grid_selection';
-import type { Annotation } from './annotation';
-import type { Sheet } from './sheet';
+import type { Annotation, GridSelection, Sheet } from 'treb-data-model';
 import type { Area } from 'treb-base-types';
-import type { ConditionalFormat } from './conditional_format';
 
 export enum ErrorCode {
 
@@ -95,9 +92,18 @@ export interface AnnotationEvent {
   event?: 'move'|'resize'|'create'|'delete'|'update';
 }
 
+export interface HyperlinkCellEventData {
+  type: 'hyperlink';
+  reference: string;
+}
+
 export interface CellEvent {
-  type: 'cell-event',
-  data?: any,
+  type: 'cell-event';
+
+  // theoretically we're going to extend this with additional types,
+  // but for now it's only used for hyperlinks.
+
+  data?: HyperlinkCellEventData;
 }
 
 export interface DataEvent {