@trebco/treb 28.15.0 → 28.17.4

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

@@ -841,33 +841,49 @@ export class GridBase {
 
       let valid = true;
 
-      sheet.cells.Apply2(area, cell => {
+      for (const cell of sheet.cells.Iterate(area)) {
+
         if (cell.style?.locked)  {
           console.info('invalid: locked cells');
-          valid = false;
+          return false;
         }
         if (cell.merge_area) {
           if (!area.Contains(cell.merge_area.start) || !area.Contains(cell.merge_area.end)) {
             console.info('invalid: merge area');
-            valid = false;
+            return false;
           }
         }
         if (cell.area) {
           if (!area.Contains(cell.area.start) || !area.Contains(cell.area.end)) {
             console.info('invalid: array');
+            return false;
+          }
+        }
+        
+      }
+
+      /*
+      sheet.cells.Apply2(area, cell => {
+        if (cell.style?.locked)  {
+          console.info('invalid: locked cells');
+          valid = false;
+        }
+        if (cell.merge_area) {
+          if (!area.Contains(cell.merge_area.start) || !area.Contains(cell.merge_area.end)) {
+            console.info('invalid: merge area');
             valid = false;
           }
         }
-        /* ok for paste
-        if (cell.table) {
-          if (!area.Contains(cell.table.area.start) || !area.Contains(cell.table.area.end)) {
-            console.info('invalid: table');
+        if (cell.area) {
+          if (!area.Contains(cell.area.start) || !area.Contains(cell.area.end)) {
+            console.info('invalid: array');
             valid = false;
           }
         }
-        */
+       
         return valid;
       });
+      */
 
       if (!valid) {
         return false;
@@ -1406,6 +1422,46 @@ export class GridBase {
             // duh, no we don't. if the cell is in the table it will have
             // a reference.
 
+            for (const cell of sheet.cells.Iterate()) {
+
+              if (cell.ValueIsFormula()) {
+                let updated_formula = false;
+                const parse_result = this.parser.Parse(cell.value);
+                if (parse_result.expression) {
+
+                  this.parser.Walk(parse_result.expression, (unit) => {
+                    if (unit.type === 'structured-reference') {
+
+                      if (unit.table.toLowerCase() === table_name || 
+                          (!unit.table && cell.table === table)) {
+                        
+                        // we may need to rewrite...
+                        for (const [key, value] of update.entries()) {
+                          if (unit.column.toLowerCase() === key) {
+
+                            // ok we need to update
+                            unit.column = value;
+                            updated_formula = true;
+
+                          }
+                        }
+
+                      }
+                    }
+                    return true;
+                  });
+                  if (updated_formula) {
+                    console.info('updating value');
+                    cell.value = '=' + this.parser.Render(parse_result.expression, {
+                      missing: '',
+                    });
+                  }
+                }
+              }
+
+            }
+
+            /*
             sheet.cells.IterateAll(cell => {
               if (cell.ValueIsFormula()) {
                 let updated_formula = false;
@@ -1442,6 +1498,7 @@ export class GridBase {
                 }
               }
             });
+            */
 
           }
         }
@@ -1843,6 +1900,7 @@ export class GridBase {
         case CommandKey.Clear:
         case CommandKey.SetNote:
         case CommandKey.SetLink:
+        case CommandKey.Indent:
         case CommandKey.UpdateBorders:
         case CommandKey.MergeCells:
         case CommandKey.UnmergeCells:
@@ -2135,6 +2193,17 @@ export class GridBase {
     for (const sheet of sheets) {
 
       // cells
+      for (const cell of sheet.cells.Iterate()) {
+        if (cell.ValueIsFormula()) {
+          const updated = this.PatchExpressionSheetName(cell.value||'', old_name, name);
+          if (updated) {
+            cell.value = updated;
+            changes++;
+          }          
+        }
+      }
+
+      /*
       sheet.cells.IterateAll((cell: Cell) => {
         if (cell.ValueIsFormula()) {
           const updated = this.PatchExpressionSheetName(cell.value||'', old_name, name);
@@ -2144,6 +2213,7 @@ export class GridBase {
           }          
         }
       });
+      */
 
       // conditionals
       if (sheet.conditional_formats?.length) {
@@ -2448,12 +2518,21 @@ export class GridBase {
     let error = false;
     area = sheet.RealArea(area); // collapse
 
+    for (const cell of sheet.cells.Iterate(area)) {
+      if (cell.area && !area.ContainsArea(cell.area)) {
+        this.Error(ErrorCode.array);
+        return;
+      }
+    }
+
+    /*
     sheet.cells.Apply(area, (cell) => {
       if (cell.area && !area.ContainsArea(cell.area)) {
         // throw new Error('can\'t change part of an array');
         error = true;
       }
     });
+    */
 
     // if the area completely encloses a table, delete the table
     const table_keys = this.model.tables.keys();
@@ -2870,6 +2949,18 @@ export class GridBase {
     for (const sheet of this.model.sheets.list) {
       const is_target = sheet === target_sheet;
 
+      for (const cell of sheet.cells.Iterate()) {
+        if (cell.ValueIsFormula()) {
+          const modified = this.PatchFormulasInternal(cell.value || '',
+            command.before_row, command.count, 0, 0,
+            target_sheet_name, is_target);
+          if (modified) {
+            cell.value = modified;
+          }
+        }
+      }
+
+      /*
       sheet.cells.IterateAll((cell: Cell) => {
         if (cell.ValueIsFormula()) {
           const modified = this.PatchFormulasInternal(cell.value || '',
@@ -2880,6 +2971,7 @@ export class GridBase {
           }
         }
       });
+      */
 
       for (const annotation of sheet.annotations) {
         if (annotation.data.formula) {
@@ -3216,6 +3308,18 @@ export class GridBase {
     for (const sheet of this.model.sheets.list) {
       const is_target = sheet === target_sheet;
 
+      for (const cell of sheet.cells.Iterate()) {
+        if (cell.ValueIsFormula()) {
+          const modified = this.PatchFormulasInternal(cell.value || '', 0, 0,
+            command.before_column, command.count,
+            target_sheet_name, is_target);
+          if (modified) {
+            cell.value = modified;
+          }
+        }
+      }
+
+      /*
       sheet.cells.IterateAll((cell: Cell) => {
         if (cell.ValueIsFormula()) {
           const modified = this.PatchFormulasInternal(cell.value || '', 0, 0,
@@ -3226,6 +3330,7 @@ export class GridBase {
           }
         }
       });
+      */
 
       for (const annotation of sheet.annotations) {
         if (annotation.data.formula) {
@@ -3760,6 +3865,15 @@ export class GridBase {
             const list: Record<string, Area> = {};
             const area = new Area(command.area.start, command.area.end);
 
+            for (const cell of sheet.cells.Iterate(area, false)) {
+              if (cell.merge_area) {
+                const label = Area.CellAddressToLabel(cell.merge_area.start) + ':'
+                  + Area.CellAddressToLabel(cell.merge_area.end);
+                list[label] = cell.merge_area;
+              }
+            }
+
+            /*
             sheet.cells.Apply(area, (cell: Cell) => {
               if (cell.merge_area) {
                 const label = Area.CellAddressToLabel(cell.merge_area.start) + ':'
@@ -3767,6 +3881,7 @@ export class GridBase {
                 list[label] = cell.merge_area;
               }
             }, false);
+            */
 
             const keys = Object.keys(list);
 
@@ -3795,6 +3910,39 @@ export class GridBase {
           }
           break;
 
+        case CommandKey.Indent:
+          {
+            let area: Area|undefined;
+            const sheet = this.FindSheet(command.area);
+
+            if (IsCellAddress(command.area)) {
+              area = new Area(command.area);
+              const style = sheet.GetCellStyle(command.area, true);
+              sheet.UpdateCellStyle(command.area, {
+                indent: Math.max(0, (style.indent || 0) + command.delta),
+              }, true);
+            }
+            else {
+              area = new Area(command.area.start, command.area.end);
+              for (const address of area) {
+                const style = sheet.GetCellStyle(address, true);
+                sheet.UpdateCellStyle(address, {
+                  indent: Math.max(0, (style.indent || 0) + command.delta),
+                }, true);
+              };
+            }
+
+            if (sheet === this.active_sheet) {
+              flags.style_area = Area.Join(area, flags.style_area);
+              flags.render_area = Area.Join(area, flags.render_area);
+            }
+            else {
+              flags.style_event = true;
+            }
+
+          }
+          break;
+
         case CommandKey.UpdateStyle:
           {
             // COEDITING: handles sheet ID properly

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

@@ -52,6 +52,7 @@ export enum CommandKey {
   SetRange,
   UpdateStyle,
   UpdateBorders,
+  Indent,
   MergeCells,
   UnmergeCells,
   Clear,
@@ -278,6 +279,12 @@ export interface UpdateBordersCommand {
   width?: number;
 }
 
+export interface IndentCommand {
+  key: CommandKey.Indent,
+  area: IArea,
+  delta: number,
+}
+
 /** update style in area. area can be cell(s), sheet, row(s), column(s) */
 export interface UpdateStyleCommand {
   key: CommandKey.UpdateStyle;
@@ -465,6 +472,7 @@ export type Command =
   | ResetCommand
   | SelectCommand
   | FreezeCommand
+  | IndentCommand
   | SetNoteCommand
   | SetLinkCommand
   | SetNameCommand

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

@@ -781,6 +781,35 @@ export class Sheet {
     // assuming we're good to go...
 
     area = area.Clone();
+
+    // so this needs the address, in order to test if it's the head;
+    // but we know the head will always be the first one tested (correct?)
+
+    const cells = [...this.cells.Iterate(area, true)];
+
+    for (const [index, cell] of cells.entries()) {
+
+      cell.merge_area = area;
+      cell.render_clean = [];
+
+      if (index) {
+        cell.Reset();
+      }
+
+    }      
+
+
+    /*
+    for (const {column, row, cell} of this.cells.IterateArea(area, true)) {
+      cell.merge_area = area;
+      cell.render_clean = [];
+
+      // clear data in !head
+      if (column !== area.start.column || row !== area.start.row) cell.Reset();
+    }
+    */
+
+    /*
     this.cells.Apply(area, (cell, c, r) => {
       cell.merge_area = area;
       cell.render_clean = [];
@@ -788,6 +817,7 @@ export class Sheet {
       // clear data in !head
       if (c !== area.start.column || r !== area.start.row) cell.Reset();
     }, true);
+    */
 
   }
 
@@ -798,7 +828,16 @@ export class Sheet {
 
     // let's check:
 
+    for (const cell of this.cells.Iterate(area, false)) {
+      if (!cell.merge_area || !area.Equals(cell.merge_area)) {
+        console.warn('area mismatch');
+        return;
+      }
+    }
+
+    /*
     let match = true;
+
     this.cells.Apply(area, (cell) => {
       match = match && !!cell.merge_area && area.Equals(cell.merge_area);
     }, false);
@@ -807,11 +846,19 @@ export class Sheet {
       console.warn('area mismatch');
       return;
     }
+    */
 
+    for (const cell of this.cells.Iterate(area, false)) {
+      cell.merge_area = undefined;
+      cell.render_clean = [];
+    }
+
+    /*
     this.cells.Apply(area, (cell) => {
       cell.merge_area = undefined;
       cell.render_clean = [];
     }, false);
+    */
 
   }
 
@@ -1091,7 +1138,13 @@ export class Sheet {
    * neighboring cells.
    */
   public Invalidate(area: Area): void {
-    this.cells.Apply(this.RealArea(area), cell => cell.render_clean = []);
+    
+    // this.cells.Apply(this.RealArea(area), cell => cell.render_clean = []);
+
+    for (const cell of this.cells.Iterate(this.RealArea(area), false)) {
+      cell.render_clean = [];
+    }
+
   }
 
   /**
@@ -1118,7 +1171,15 @@ export class Sheet {
         this.UpdateRowStyle(row, style, delta);
       }
     }
-    else area.Array().forEach((address) => this.UpdateCellStyle(address, style, delta));
+    else {
+
+      // area.Array().forEach((address) => this.UpdateCellStyle(address, style, delta));
+
+      for (const address of area) {
+        this.UpdateCellStyle(address, style, delta);
+      }
+
+    }
 
   }
 
@@ -1699,10 +1760,18 @@ export class Sheet {
       const patched = new Area(
         { row: head.start.row + count, column: head.start.column },
         { row: head.end.row + count, column: head.end.column });
+
+      for (const address of patched) {
+        const cell = this.cells.GetCell(address, true);
+        cell.area = patched;
+      }
+
+      /*
       patched.Iterate((address) => {
         const cell = this.cells.GetCell(address, true);
         cell.area = patched;
       });
+      */
     }
 
     /*
@@ -1734,10 +1803,18 @@ export class Sheet {
       const patched = new Area(
         patched_start,
         { row: head.end.row + count, column: head.end.column });
+
+      for (const address of patched) {
+        const cell = this.cells.GetCell(address, true);
+        cell.merge_area = patched;
+      }
+
+      /*
       patched.Iterate((address) => {
         const cell = this.cells.GetCell(address, true);
         cell.merge_area = patched;
       });
+      */
     }
 
     // row styles
@@ -1853,10 +1930,18 @@ export class Sheet {
       const patched = new Area(
         { row: head.start.row, column: head.start.column + count },
         { row: head.end.row, column: head.end.column + count });
+
+      for (const address of patched) {
+        const cell = this.cells.GetCell(address, true);
+        cell.area = patched;
+      }
+
+      /*
       patched.Iterate((address) => {
         const cell = this.cells.GetCell(address, true);
         cell.area = patched;
       });
+      */
     }
 
     for (const key of Object.keys(merge_heads)) {
@@ -1866,10 +1951,19 @@ export class Sheet {
       const patched = new Area(
         patched_start,
         { row: head.end.row, column: head.end.column + count });
+
+      for (const address of patched) {
+        const cell = this.cells.GetCell(address, true);
+        cell.merge_area = patched;
+      }
+
+      /*
       patched.Iterate((address) => {
         const cell = this.cells.GetCell(address, true);
         cell.merge_area = patched;
       });
+      */
+     
     }
 
     // column styles
@@ -1925,8 +2019,12 @@ export class Sheet {
 
     // assuming it's ok, :
 
-    area = this.RealArea(area);
-    this.cells.Apply(area, (cell) => cell.Reset());
+    // area = this.RealArea(area);
+    // this.cells.Apply(area, (cell) => cell.Reset());
+
+    for (const cell of this.cells.Iterate(this.RealArea(area), false)) {
+      cell.Reset();
+    }
 
   }
 
@@ -1957,7 +2055,13 @@ export class Sheet {
    */
   public SetArrayValue(area: Area, value: CellValue): void {
     area = this.RealArea(area);
-    this.cells.Apply(area, (element) => element.SetArray(area), true);
+
+    // this.cells.Apply(area, (element) => element.SetArray(area), true);
+
+    for (const cell of this.cells.Iterate(area, true)) {
+      cell.SetArray(area);
+    }
+
     const cell = this.cells.GetCell(area.start, true);
     cell.SetArrayHead(area, value);
   }
@@ -2048,6 +2152,15 @@ export class Sheet {
 
   }
 
+  /** specialization */
+  public GetCellStyle(area: ICellAddress, apply_theme?: boolean): CellStyle;
+
+  /** specialization */
+  public GetCellStyle(area: IArea, apply_theme?: boolean): CellStyle[][];
+
+  /** extra specialization */
+  public GetCellStyle<K extends ICellAddress|IArea>(area: K, apply_theme?: boolean): CellStyle|CellStyle[][];
+
   /**
    * this is a new GetCellStyle function, used for external access
    * to style (for API access). there was an old GetCellStyle function
@@ -2970,7 +3083,10 @@ export class Sheet {
 
     // FIXME: ROW PATTERN
 
-    this.cells.Apply(this.RealArea(Area.FromRow(row)), (cell) => cell.FlushStyle());
+    // this.cells.Apply(this.RealArea(Area.FromRow(row)), (cell) => cell.FlushStyle());
+    for (const cell of this.cells.Iterate(this.RealArea(Area.FromRow(row)))) {
+      cell.FlushStyle();
+    }
 
   }
 
@@ -3019,7 +3135,11 @@ export class Sheet {
       }
     }
 
-    this.cells.Apply(this.RealArea(Area.FromColumn(column)), (cell) => cell.FlushStyle());
+    // this.cells.Apply(this.RealArea(Area.FromColumn(column)), (cell) => cell.FlushStyle());
+
+    for (const cell of this.cells.Iterate(this.RealArea(Area.FromColumn(column)))) {
+      cell.FlushStyle();
+    }
 
     // FIXME: ROW PATTERN