@trebco/treb 28.15.1 → 28.17.5

package/treb-grid/src/render/tile_renderer.ts

@@ -23,7 +23,8 @@ import type { ICellAddress,
          PreparedText, RenderTextPart,
          Cell, Size, 
          CellStyle,
-         Theme} from 'treb-base-types';
+         Theme,
+         HorizontalAlign} from 'treb-base-types';
 import { TextPartFlag, Style, ValueType, Area, Rectangle, ThemeColor, ThemeColor2 } from 'treb-base-types';
 
 import type { Tile } from '../types/tile';
@@ -146,12 +147,22 @@ export class TileRenderer {
     // flush all, mark dirty and drop areas.
 
     const cells = this.view.active_sheet.cells;
+
+    for (const cell of cells.Iterate()) {
+      if (cell.renderer_data?.overflowed) {
+        cell.renderer_data = undefined;
+        cell.render_clean[this.view.view_index] = false;
+      }
+    }
+
+    /*
     cells.IterateAll(cell => {
       if (cell.renderer_data?.overflowed) {
         cell.renderer_data = undefined;
         cell.render_clean[this.view.view_index] = false;
       }
     });
+    */
 
     for (const overflow_area of this.overflow_areas) {
       overflow_area.tile.dirty = true;
@@ -727,10 +738,22 @@ export class TileRenderer {
     // precalculate indent as string so we can use layout
 
     let indent = '';
+    let align: HorizontalAlign|undefined;
+
     if (style.indent) {
+
       for (let i = 0; i < style.indent; i++) {
         indent += DEFAULT_INDENT;
       }
+
+      align = style.horizontal_align;
+
+      // default might be left or right based on type
+
+      if (!align) {
+        align = (cell.type === ValueType.number || cell.calculated_type === ValueType.number) ? 'right' : 'left';
+      }
+      
     }
 
     if (Array.isArray(formatted)) {
@@ -744,10 +767,11 @@ export class TileRenderer {
       // this is a single line, with number formatting
 
       if (indent) {
-        if (style.horizontal_align === 'right') {
+
+        if (align === 'right') {
           formatted.push({ text: indent });
         }
-        else if (style.horizontal_align !== 'center') {
+        else if (align === 'left') {
           formatted.unshift({ text: indent });
         }
       }
@@ -953,13 +977,12 @@ export class TileRenderer {
             });
 
             if (style.indent) {
-              if (style.horizontal_align === 'right') {
+              if (align === 'right') {
                 line_string.push({ text: indent, hidden: false, width: indent_width });
               }
-              else if (style.horizontal_align !== 'center') {
+              else if (align === 'left') {
                 line_string.unshift({ text: indent, hidden: false, width: indent_width });
               }
-    
             }
 
             strings.push(line_string);
@@ -978,13 +1001,12 @@ export class TileRenderer {
           const parts: RenderTextPart[] = [];
 
           if (style.indent) {
-            if (style.horizontal_align === 'right') {
+            if (align === 'right') {
               line.push({ text: indent });
             }
-            else if (style.horizontal_align !== 'center') {
+            else if (align === 'left') {
               line.unshift({ text: indent });
             }
-    
           }
 
           let line_width = 0;

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

@@ -2044,6 +2044,21 @@ export class Grid extends GridBase {
   }
   */
 
+  public Indent(area?: Area, delta = 0): void {
+
+    if (!area) {
+      if (this.primary_selection.empty) { return; }
+      area = this.primary_selection.area;
+    }
+
+    this.ExecCommand({
+      key: CommandKey.Indent,
+      area, 
+      delta,
+    });
+
+  }
+
   /** updated API method, probably change the name */
   public ApplyBorders2(area?: Area, borders: BorderConstants = BorderConstants.None, color?: Color, width = 1): void {
 
@@ -4972,6 +4987,15 @@ export class Grid extends GridBase {
       }
     }
     else if (array) {
+
+      for (const cell of this.active_sheet.cells.Iterate(selection.area, false)) {
+        if (cell.area) {
+          this.Error(ErrorCode.array);
+          return;
+        }
+      }
+
+      /*
       let existing_array = false;
       this.active_sheet.cells.Apply(selection.area, (element: Cell) => {
         if (element.area) {
@@ -4982,6 +5006,8 @@ export class Grid extends GridBase {
         this.Error(ErrorCode.array);
         return;
       }
+      */
+
     }
 
     if (cell.validation && cell.validation.error) {
@@ -6099,9 +6125,28 @@ export class Grid extends GridBase {
       let real_area = this.active_sheet.RealArea(area);
       if (!target) target = real_area.start;
 
-      let recheck = true;
+      // there has to be a better way to do this... 
+
+      // the operation here is composing the selection by adding all merge
+      // areas. the issue is that when you do that, you might be adding other
+      // cells that are not in the merge area (because the selection has to
+      // 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.
+
+      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)) {
+            area.ConsumeArea(cell.merge_area);
+            real_area = this.active_sheet.RealArea(area);
+            continue recheck_loop;
+          }
+        }
+        break;
+      }
 
-      // there has to be a better way to do this...
+      /*
+
+      let recheck = true;
 
       while (recheck) {
         recheck = false;
@@ -6113,6 +6158,7 @@ export class Grid extends GridBase {
           }
         });
       }
+      */
 
       selection.area = new Area({ ...area.start, sheet_id: this.active_sheet.id }, area.end);
       if (target) {

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