@trebco/treb 29.5.4 → 29.7.5

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

@@ -116,6 +116,7 @@ import type { ClipboardCellData } from './clipboard_data';
 
 import type { ExternalEditorConfig } from './external_editor_config';
 import { ExternalEditor } from '../editors/external_editor';
+import type { ClipboardData, PasteOptions } from './clipboard_data2';
 
 interface DoubleClickData {
   timeout?: number;
@@ -416,6 +417,227 @@ export class Grid extends GridBase {
         
   }
 
+
+  // --- Copy/paste API methods ------------------------------------------------
+  //
+  // moving here with a view towards (eventually) merging with the UI/browser
+  // copy/paste routines (in grid)
+  //
+
+
+  /**
+   * internal composite for cut/copy. mostly identical except we 
+   * read data as A1 for cut, so it will retain references. also
+   * cut clears the data.
+   * 
+   * FIXME: merge with grid cut/copy/paste routines. we already
+   * handle recycling and relative addressing, the only thing missing
+   * is alternate formats.
+   */
+  public CopyArea(resolved: Area, semantics: 'cut'|'copy' = 'copy'): ClipboardData {
+
+    // resolve range so we can use it later -> Area
+    const sheet = (resolved.start.sheet_id ? this.model.sheets.Find(resolved.start.sheet_id) : this.active_sheet) || this.active_sheet;
+
+    // get style data, !apply theme but do apply r/c styles
+    const style_data = sheet.GetCellStyle(resolved, false);
+
+    // flag we want R1C1 (copy)
+    const r1c1 = (semantics !== 'cut');
+
+    // NOTE: we're losing arrays here. need to fix. also think
+    // about merges? we'll reimplement what grid does (only in part)
+
+    const data: ClipboardData = [];
+
+    for (const { cell, row, column } of sheet.cells.IterateRC(resolved)) {
+
+      // raw value
+      let value = cell.value;
+
+      // seems like we're using a loop function unecessarily
+      if (r1c1 && value && cell.type === ValueType.formula) {
+        value = this.FormatR1C1(value, { row, column })[0][0];
+      }
+
+      const r = row - resolved.start.row;
+      const c = column - resolved.start.column;
+
+      if (!data[r]) { 
+        data[r] = [];
+      }
+
+      let array_head: IArea|undefined;
+      if (cell.area) {
+
+        // scrubbing to just area (and unlinking)
+        array_head = {
+          start: {
+            row: cell.area.start.row - resolved.start.row,
+            column: cell.area.start.column - resolved.start.column,
+          },
+          end: {
+            row: cell.area.end.row - resolved.start.row,
+            column: cell.area.end.column - resolved.start.column,
+          },
+        };
+
+      }
+
+      data[r][c] = {
+        value,
+        calculated: cell.calculated,
+        style: style_data[r][c],
+        area: array_head,
+      };
+      
+    }     
+
+    // EmbeddedSpreadsheet.clipboard = structuredClone(data);
+
+    if (semantics === 'cut') {
+      this.SetRange(resolved, undefined, { recycle: true }); // clear
+    }
+
+    return data;
+        
+  }  
+  
+  /**
+   * paste clipboard data into a target range. this method does not use
+   * the system clipboard; pass in clipboard data returned from the Cut or
+   * Copy method.
+   * 
+   * @param target - the target to paste data into. this can be larger 
+   * than the clipboard data, in which case values will be recycled in 
+   * blocks. if the target is smaller than the source data, we will expand
+   * it to fit the data.
+   * 
+   * @param data - clipboard data to paste.
+   * 
+   * @privateRemarks LLM API
+   * 
+   * @privateRemarks this was async when we were thinking of using the 
+   * system clipboard, but that's pretty broken so we're not going to
+   * bother atm.
+   */
+  public PasteArea(resolved: Area, data: ClipboardData, options: PasteOptions = {}): void {
+
+    if (!data) {
+      throw new Error('no clipboad data');
+    }
+
+    // paste has some special semantics. if the target smaller than the
+    // source data, we write the full data irrespective of size (similar 
+    // to "spill"). otherwise, we recycle in blocks. 
+
+    // the setrange method will recycle, but we also need to recycle styles.
+
+    // start with data length
+
+    const rows = data.length;
+    const columns = data[0]?.length || 0;
+
+    // target -> block size
+
+    resolved.Resize(
+      Math.max(1, Math.floor(resolved.rows / rows)) * rows, 
+      Math.max(1, Math.floor(resolved.columns / columns)) * columns );
+
+    const sheet = (resolved.start.sheet_id ? this.model.sheets.Find(resolved.start.sheet_id) : this.active_sheet) || this.active_sheet;
+      
+    const values: CellValue[][] = [];
+
+    // optionally collect calculated values, instead of raw values
+
+    if (options.values) {
+      for (const [index, row] of data.entries()) {
+        values[index] = [];
+        for (const cell of row) {
+          values[index].push(typeof cell.calculated === 'undefined' ? cell.value : cell.calculated);
+        }
+      }
+    }
+
+    // this is to resolve the reference in the callback,
+    // but we should copy -- there's a possibility that
+    // this points to the static member, which could get
+    // overwritten. FIXME
+    
+    const local = data; 
+
+    // batch to limit events, sync up undo
+
+    const events = this.Batch(() => {
+
+      // this needs to change to support arrays (and potentially merges...)
+
+      // actually we could leave as is for just calculated values
+
+      if (options.values) {
+        this.SetRange(resolved, values, {
+          r1c1: true, recycle: true,
+        });
+      }
+      else {
+
+        // so this is for formulas only now
+
+        // start by clearing... (but leave styles as-is for now)
+
+        // probably a better way to do this
+        this.SetRange(resolved, undefined, { recycle: true });
+
+        for (const address of resolved) {
+          const r = (address.row - resolved.start.row) % rows;
+          const c = (address.column - resolved.start.column) % columns;
+          
+          const cell_data = local[r][c];
+
+          if (cell_data.area) {
+            // only the head
+            if (cell_data.area.start.row === r && cell_data.area.start.column === c) {
+              const array_target = new Area(cell_data.area.start, cell_data.area.end);
+              array_target.Shift(resolved.start.row, resolved.start.column);
+              this.SetRange(array_target, cell_data.value, { r1c1: true, array: true });
+            }
+          }
+          else if (cell_data.value) {
+            this.SetRange(new Area(address), cell_data.value, { r1c1: true });
+          }
+
+        }
+
+      }
+
+      if (options.formatting === 'number-formats') {
+
+        // number format only, and apply delta
+
+        for (const address of resolved) {
+          const r = (address.row - resolved.start.row) % rows;
+          const c = (address.column - resolved.start.column) % columns;
+          const number_format = (local[r][c].style || {}).number_format;
+          sheet.UpdateCellStyle(address, { number_format }, true);
+        }
+      }
+      else if (options.formatting !== 'target') {
+
+        // use source formatting (default)
+        for (const address of resolved) {
+          const r = (address.row - resolved.start.row) % rows;
+          const c = (address.column - resolved.start.column) % columns;
+          sheet.UpdateCellStyle(address, local[r][c].style || {}, false);
+        }
+
+      }
+
+    }, true);
+
+    this.grid_events.Publish(events);
+
+  }
+
   // --- public methods --------------------------------------------------------
 
   /**
@@ -1883,23 +2105,19 @@ export class Grid extends GridBase {
       let convert = false;
 
       if (options.argument_separator === ',' && this.parser.argument_separator !== ArgumentSeparatorType.Comma) {
-        // this.parser.argument_separator = ArgumentSeparatorType.Comma;
-        // this.parser.decimal_mark = DecimalMarkType.Period;
         this.parser.SetLocaleSettings(DecimalMarkType.Period);
-
         convert = true;
       }
        
       if (options.argument_separator === ';' && this.parser.argument_separator !== ArgumentSeparatorType.Semicolon) {
-        // this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
-        // this.parser.decimal_mark = DecimalMarkType.Comma;
         this.parser.SetLocaleSettings(DecimalMarkType.Comma);
-
         convert = true;
       }
 
       if (convert) {
 
+        this.parser.flags.r1c1 = r1c1;
+
         const Convert = (value: CellValue): CellValue => {
           if (typeof value === 'string' && value[0] === '=') {
             const result = this.parser.Parse(value);
@@ -1908,8 +2126,10 @@ export class Grid extends GridBase {
                 missing: '', 
                 convert_decimal: current.decimal_mark, 
                 convert_argument_separator: current.argument_separator,
+                pass_through_addresses: true,
               });
             }
+            // console.info("CVT", this.parser.flags, result.expression, value);
           }
           return value;
         };
@@ -2176,21 +2396,40 @@ export class Grid extends GridBase {
   /**
    * batch updates. returns all the events that _would_ have been sent.
    * also does a paint (can disable).
+   * 
+   * update for nesting/stacking. we won't return events until the last
+   * batch is complete. paint will similarly toll until the last batch
+   * is complete, and we'll carry forward any paint requirement from 
+   * inner batch funcs.
+   * 
    * @param func 
    */
   public Batch(func: () => void, paint = true): GridEvent[] {
     
-    this.batch = true;
+    if (this.batch === 0) {
+      this.batch_paint = paint; // clear any old setting
+    }
+    else {
+      this.batch_paint = this.batch_paint || paint; // ensure we honor it at the end
+    }
+
+    this.batch++;
     func();
-    this.batch = false;
-    const events = this.batch_events.slice(0);
-    this.batch_events = [];
+    this.batch--;
+
+    if (this.batch === 0) {
+      const events = this.batch_events.slice(0);
+      this.batch_events = [];
 
-    if (paint) {
-      this.DelayedRender(false);
+      if (this.batch_paint) {
+        this.DelayedRender(false);
+      }
+
+      return events;
     }
 
-    return events;
+    return []; // either nothing happened or we're not done
+
   }
 
 

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

@@ -109,7 +109,19 @@ export class GridBase {
 
   // --- protected members -----------------------------------------------------
 
-  protected batch = false;
+  /** 
+   * switching to a stack, in case batching is nested. we don't need
+   * actual data so (atm) just count the depth.
+   */
+  protected batch = 0; // false;
+
+  /** 
+   * if any batch method along the way requests a paint update, we 
+   * want to toll it until the last batch call is complete, but we don't
+   * want to lose it. just remember to reset. [FIXME: isn't tolling this
+   * paint implicit, since it's async? ...]
+   */
+  protected batch_paint = false;
 
   protected batch_events: GridEvent[] = [];
 
@@ -4474,7 +4486,7 @@ export class GridBase {
       });
     }
 
-    if (this.batch) {
+    if (this.batch > 0) {
       this.batch_events.push(...events);
     }
     else {

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

@@ -411,6 +411,9 @@ export interface RenderOptions {
   /** base for offsetting relative R1C1 addresses */
   r1c1_base?: UnitAddress;
 
+  /** if we're just translating, don't have to render addresses */
+  pass_through_addresses?: boolean;
+
   missing: string;
   convert_decimal: DecimalMarkType;
   convert_argument_separator: ArgumentSeparatorType;

package/treb-parser/src/parser.ts

@@ -34,6 +34,7 @@ import type {
   ParserFlags,
   UnitStructuredReference,
   RenderOptions,
+  BaseExpressionUnit,
 } from './parser-types';
 import {
   ArgumentSeparatorType,
@@ -334,6 +335,77 @@ export class Parser {
     }
   }
 
+  /** 
+   * recursive tree walk that allows substitution. this should be 
+   * a drop-in replacement for the original Walk function but I'm
+   * keeping it separate temporarily just in case it breaks something.
+   * 
+   * @param func - in this version function can return `true` (continue
+   * walking subtree), `false` (don't walk subtree), or an ExpressionUnit.
+   * in the last case, we'll replace the original unit with the substitution.
+   * obviously in that case we don't recurse.
+   */
+  public Walk2(unit: ExpressionUnit, func: (unit: ExpressionUnit) => boolean|ExpressionUnit|undefined): ExpressionUnit {
+
+    const result = func(unit);
+    if (typeof result === 'object') {
+      return result;
+    }
+
+    switch (unit.type) {
+      case 'address':
+      case 'missing':
+      case 'literal':
+      case 'complex':
+      case 'identifier':
+      case 'operator':
+      case 'structured-reference':
+        break;
+
+      case 'dimensioned':
+        if (result) {
+          unit.expression = this.Walk2(unit.expression, func) as BaseExpressionUnit; // could be an issue
+          unit.unit = this.Walk2(unit.unit, func) as UnitIdentifier; // could be an issue
+        }
+        break;
+
+      case 'range':
+        if (func(unit)) {
+          unit.start = this.Walk2(unit.start, func) as UnitAddress; // could be an issue
+          unit.end = this.Walk2(unit.end, func) as UnitAddress; // could be an issue
+        }
+        break;
+
+      case 'binary':
+        if (func(unit)) {
+          unit.left = this.Walk2(unit.left, func);
+          unit.right = this.Walk2(unit.right, func);
+        }
+        break;
+
+      case 'unary':
+        if (func(unit)) {
+          unit.operand = this.Walk2(unit.operand, func);
+        }
+        break;
+
+      case 'group':
+        if (func(unit)) {
+          unit.elements = unit.elements.map(source => this.Walk2(source, func));
+        }
+        break;
+
+      case 'call':
+        if (func(unit)) {
+          unit.args = unit.args.map(source => this.Walk2(source, func));
+        }
+        break;
+    }
+
+    return unit;
+
+  }
+
   /**
    * recursive tree walk.
    *
@@ -382,13 +454,19 @@ export class Parser {
 
       case 'group':
         if (func(unit)) {
-          unit.elements.forEach((element) => this.Walk(element, func));
+          // unit.elements.forEach((element) => this.Walk(element, func));
+          for (const element of unit.elements) {
+            this.Walk(element, func);
+          }
         }
         return;
 
       case 'call':
         if (func(unit)) {
-          unit.args.forEach((arg) => this.Walk(arg, func));
+          for (const arg of unit.args) {
+            this.Walk(arg, func);
+          }
+          // unit.args.forEach((arg) => this.Walk(arg, func));
         }
     }
   }
@@ -489,9 +567,15 @@ export class Parser {
 
     switch (unit.type) {
       case 'address':
+        if (options.pass_through_addresses) { 
+          return unit.label;
+        }
         return options.r1c1 ? this.R1C1Label(unit, options.r1c1_base) : this.AddressLabel(unit, offset);
 
       case 'range':
+        if (options.pass_through_addresses) { 
+          return unit.label;
+        }
         return options.r1c1 ? 
           this.R1C1Label(unit.start, options.r1c1_base) + ':' + this.R1C1Label(unit.end, options.r1c1_base) : 
           this.AddressLabel(unit.start, offset) + ':' + this.AddressLabel(unit.end, offset);