@trebco/treb 28.7.0 → 28.10.5

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

@@ -67,6 +67,10 @@ interface PatchOptions extends PatchAreaOptions {
   sheet: Sheet;
 }
 
+const AssertNever = (value: never) => {
+  console.error('invalid case');
+};
+
 export class GridBase {
 
   // --- public members --------------------------------------------------------
@@ -160,6 +164,24 @@ export class GridBase {
 
   // --- API methods -----------------------------------------------------------
 
+  public RemoveConditionalFormat(options: {
+        format?: ConditionalFormat;
+        area?: IArea;
+      }) {
+
+    this.ExecCommand({
+      key: CommandKey.RemoveConditionalFormat,
+      ...options,
+    });
+  }
+
+  public AddConditionalFormat(format: ConditionalFormat) {
+    this.ExecCommand({
+      key: CommandKey.AddConditionalFormat,
+      format,
+    });
+  }
+
   /** remove a table. doesn't remove any data, just removes the overlay. */
   public RemoveTable(table: Table) {
     this.ExecCommand({
@@ -1887,7 +1909,7 @@ export class GridBase {
           break;
         */
 
-        // special case
+        // special cases
         case CommandKey.SortTable:
         case CommandKey.RemoveTable:
           if (!command.table.area.start.sheet_id) {
@@ -1895,6 +1917,12 @@ export class GridBase {
           }
           break;
 
+        case CommandKey.AddConditionalFormat:
+          if (!command.format.area.start.sheet_id) {
+            command.format.area.start.sheet_id = id;
+          }
+          break;
+
         // field
         case CommandKey.ResizeRows:
         case CommandKey.ResizeColumns:
@@ -1920,6 +1948,14 @@ export class GridBase {
         case CommandKey.Select:
         case CommandKey.InsertTable:
 
+        // note that remove conditional format could have a format
+        // object (with an area) instead of an area. but in that case,
+        // the format object must match an existing format, so it would
+        // have to have a proper area. there's no case where we would
+        // want to add it. so we only handle the area case.
+
+        case CommandKey.RemoveConditionalFormat:
+
           if (command.area) {
             if (IsCellAddress(command.area)) {
               if (!command.area.sheet_id) {
@@ -1934,10 +1970,13 @@ export class GridBase {
           }
           break;
 
-        // default:
-        //  // command key here should be `never` if we've covered all the 
-        //  // cases (ts will complain)
-        //  // console.warn('unhandled command key', command.key);
+        default:
+
+          // this is intended to check that we've handled all cases. if you
+          // add additional commands and they're not handled, this should 
+          // raise a ts error.
+
+          AssertNever(command);
 
       }
     }
@@ -2231,6 +2270,16 @@ export class GridBase {
       }
     }
 
+    for (const element of this.model.connected_elements.values()) {
+      if (element.formula) {
+        const updated = this.PatchExpressionSheetName(element.formula, old_name, name);
+        if (updated) {
+          element.formula = updated;
+          changes++;
+        }
+      }
+    }
+
     return changes;
 
   }
@@ -2811,6 +2860,18 @@ export class GridBase {
         row_count: command.count
       });
 
+    // connected elements
+    for (const external of this.model.connected_elements.values()) {
+      if (external.formula) {
+        const modified = this.PatchFormulasInternal(external.formula,
+          command.before_row, command.count, 0, 0,
+          target_sheet.name.toLowerCase(), false);
+        if (modified) {
+          external.formula = modified;
+        }
+      }
+    }
+
     // see InsertColumnsInternal re: tables. rows are less complicated,
     // except that if you delete the header row we want to remove the 
     // table entirely.
@@ -3133,6 +3194,18 @@ export class GridBase {
       before_row: 0, 
       row_count: 0 });
 
+    // connected elements
+    for (const element of this.model.connected_elements.values()) {
+      if (element.formula) {
+        const modified = this.PatchFormulasInternal(element.formula,
+          0, 0, command.before_column, command.count,
+          target_sheet.name.toLowerCase(), false);
+        if (modified) {
+          element.formula = modified;
+        }
+      }
+    }
+
     // patch tables. we removed this from the sheet routine entirely,
     // we need to rebuild any affected tables now.
 
@@ -3534,6 +3607,88 @@ export class GridBase {
 
           break;
 
+        case CommandKey.AddConditionalFormat:
+          {
+
+            const sheet = this.FindSheet(command.format.area);
+            sheet.conditional_formats.push(command.format);
+
+            sheet.Invalidate(new Area(command.format.area.start, command.format.area.end));
+
+            if (sheet === this.active_sheet) {
+              // flags.style_area = Area.Join(command.format.area, flags.style_area);
+              flags.render_area = Area.Join(command.format.area, flags.render_area);
+            }
+            else {
+              // flags.style_event = true;
+            }
+
+            flags.structure_event = true;
+            flags.conditional_formatting_event = true;
+
+          }
+          break;
+
+        case CommandKey.RemoveConditionalFormat:
+
+          {
+            let sheet: Sheet|undefined;
+            let count = 0;
+
+            if (command.format) {
+
+              // we're removing by object equivalence, not strict equality.
+              // this is in case we're switching contexts and the objects
+              // are not strictly equal. may be unecessary. do we need to
+              // normalize in some way? (...)
+
+              const format = JSON.stringify(command.format);
+
+              sheet = this.FindSheet(command.format.area);
+              sheet.conditional_formats = sheet.conditional_formats.filter(test => {
+                // if (test === command.format) {
+                if (JSON.stringify(test) === format) {
+                  count++;
+                  flags.render_area = Area.Join(test.area, flags.render_area);
+                  return false;
+                }
+                return true;
+              });
+
+            }
+            else if (command.area) {
+              const area = new Area(command.area.start, command.area.end);
+              sheet = this.FindSheet(command.area);
+
+              sheet.conditional_formats = sheet.conditional_formats.filter(test => {
+                const compare = new Area(test.area.start, test.area.end);
+                if (compare.Intersects(area)) {
+                  count++;
+                  flags.render_area = Area.Join(compare, flags.render_area);
+                  return false;
+                }
+                return true;
+              });
+        
+            }
+
+            if (sheet && count) {
+              sheet.FlushConditionalFormats();
+              flags.structure_event = true;
+
+              // this will flush leaf vertices. but it's expensive because
+              // it's rebuilding the whole graph. we could maybe reduce a 
+              // bit... the question is what's worse: rebuilding the graph
+              // or leaving orphans for a while?
+
+              // flags.structure_rebuild_required = true;
+
+              flags.conditional_formatting_event = true;
+            }
+
+          }
+          break;
+
         case CommandKey.InsertTable:
 
           // the most important thing here is validating that we can
@@ -4170,6 +4325,7 @@ export class GridBase {
       events.push({
         type: 'structure',
         rebuild_required: flags.structure_rebuild_required,
+        conditional_format: flags.conditional_formatting_event,
       });
     }
 

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

@@ -22,6 +22,7 @@
 import type { ICellAddress, IArea, Style, 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';
 
 /**
  * switching to an exec-command based model, so we can serialize
@@ -73,6 +74,9 @@ export enum CommandKey {
   InsertTable,
   RemoveTable,
 
+  AddConditionalFormat,
+  RemoveConditionalFormat,
+
 }
 
 /** base type for sheet commands -- can select sheet by name, id or index */
@@ -418,6 +422,32 @@ export interface ReorderSheetCommand {
   move_before: number;
 }
 
+/**
+ * add conditional format
+ */
+export interface AddConditionalFormatCommand {
+  key: CommandKey.AddConditionalFormat;
+  format: ConditionalFormat;
+}
+
+/**
+ * remove conditional format, either as an object or from a target 
+ * area. as an object, we'll match using object equivalence and not 
+ * identity. 
+ */
+export interface RemoveConditionalFormatCommand {
+
+  key: CommandKey.RemoveConditionalFormat;
+
+  /** if format is omitted, we will remove all formats from the target range */
+  format?: ConditionalFormat;
+
+  /** one of area or format should be supplied */
+  area?: IArea; 
+
+}
+
+
 /**
  * ephemeral flag added to commands.
  * /
@@ -459,6 +489,8 @@ export type Command =
   | ActivateSheetCommand
   | DataValidationCommand
   | DuplicateSheetCommand
+  | AddConditionalFormatCommand
+  | RemoveConditionalFormatCommand
   ) ; // & Ephemeral;
 
 /**

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

@@ -23,6 +23,7 @@ import type { GridSelection } from './grid_selection';
 import type { Annotation } from './annotation';
 import type { Sheet } from './sheet';
 import type { Area } from 'treb-base-types';
+import type { ConditionalFormat } from './conditional_format';
 
 export enum ErrorCode {
 
@@ -80,6 +81,12 @@ export interface StructureEvent {
    * FIXME: merge/unmerge? (...) I think yes
    */
   rebuild_required?: boolean;
+
+  /** 
+   * we can use this when conditional formats are modified/added/removed 
+   */
+  conditional_format?: boolean;
+  
 }
 
 export interface AnnotationEvent {

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

@@ -24,6 +24,14 @@ import type { StatsEntry } from './tab_bar';
 
 export type StatsFunction = (data: CellValue|CellValue[][]|undefined) => StatsEntry[];
 
+
+/**
+ * @internalRemarks
+ * 
+ * why are there two levels of options? can we consolidate this with
+ * the embedded spreadsheet options? they are never (AFAICT) used 
+ * independently. maybe that's recent.
+ */
 export interface GridOptions {
 
   /** can expand rows/columns */

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

@@ -3232,62 +3232,6 @@ export class Sheet {
 
   }
 
-  /*
-  public ApplyConditionalFormats() {
-
-    this.FlushConditionalFormatCache();
-
-    for (const entry of this.conditional_formats) {
-
-      console.info({entry});
-
-      if (entry.applied) {
-        this.ApplyConditionalFormatCache(entry);
-      }
-    }
-
-  }
-
-  public FlushConditionalFormatCache() {
-
-    // FIXME: need to flush any styles that are set, unless they match;
-    // perhaps we should use an alternate cache so we can compare? TODO/FIXME
-
-    for (const [row, row_data] of this.conditional_format_cache.entries()) {
-      if (row_data) {
-        for (const [column, column_data] of row_data.entries()) {
-          if (column_data) {
-
-            this.CellData({row, column}).FlushStyle();
-
-          }
-        }
-      }
-    }
-
-    this.conditional_format_cache = [];
-
-  }
-
-  public ApplyConditionalFormatCache(format: ConditionalFormat) {
-    
-    for (let row = format.area.start.row; row <= format.area.end.row; row++ ) {
-      for (let column = format.area.start.column; column <= format.area.end.column; column++ ) {
-        if (!this.conditional_format_cache[row]) {
-          this.conditional_format_cache[row] = [];
-        }
-        if (!this.conditional_format_cache[row][column]) {
-          this.conditional_format_cache[row][column] = [];
-        }
-        this.conditional_format_cache[row][column].push(format.style);
-        this.CellData({row, column}).FlushStyle();
-
-      }
-    }
-
-  }
-  */
-
   private ConditionalFormatForCell(address: ICellAddress): CellStyle[] {
     if (this.conditional_format_cache[address.row]) {
       return this.conditional_format_cache[address.row][address.column] || [];

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

@@ -64,6 +64,7 @@ export interface UpdateFlags {
 
   data_event?: boolean;
   style_event?: boolean;
+  conditional_formatting_event?: boolean;
   structure_event?: boolean;
   structure_rebuild_required?: boolean;
 

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

@@ -395,3 +395,9 @@ export interface RenderOptions {
   long_structured_references: boolean;
   table_name: string;
 }
+
+export interface PersistedParserConfig {
+  flags: Partial<ParserFlags>;
+  argument_separator: ArgumentSeparatorType;
+  decimal_mark: DecimalMarkType;
+}

package/treb-parser/src/parser.ts

@@ -33,7 +33,8 @@ import type {
   UnitLiteralNumber,
   ParserFlags,
   UnitStructuredReference,
-  RenderOptions} from './parser-types';
+  RenderOptions,
+  PersistedParserConfig} from './parser-types';
 import {
   ArgumentSeparatorType,
   DecimalMarkType
@@ -248,6 +249,52 @@ export class Parser {
    */
   protected full_reference_list: Array<UnitAddress | UnitRange | UnitIdentifier | UnitStructuredReference> = [];
 
+  protected parser_state: string[] = [];
+
+  /**
+   * save local configuration to a buffer, so it can be restored. we're doing
+   * this because in a lot of places we're caching parser flagss, changing
+   * them, and then restoring them. that's become repetitive, fragile to 
+   * changes or new flags, and annoying.
+   * 
+   * config is managed in a list with push/pop semantics. we store it as 
+   * JSON so there's no possibility we'll accidentally mutate.
+   * 
+   * FIXME: while we're at it why not migrate the separators -> flags, so
+   * there's a single location for this kind of state? (...TODO)
+   * 
+   */
+  public Save() {
+    const config: PersistedParserConfig = {
+      flags: this.flags,
+      argument_separator: this.argument_separator,
+      decimal_mark: this.decimal_mark,
+    }
+    this.parser_state.push(JSON.stringify(config));
+  }
+
+  /**
+   * restore persisted config
+   * @see Save
+   */
+  public Restore() {
+    const json = this.parser_state.shift();
+    if (json) {
+      try {
+        const config = JSON.parse(json) as PersistedParserConfig;
+        this.flags = config.flags;
+        this.argument_separator = config.argument_separator;
+        this.decimal_mark = config.decimal_mark;
+      }
+      catch (err) {
+        console.error(err);
+      }
+    }
+    else {
+      console.warn("No parser state to restore");
+    }
+  }
+
   /**
    * recursive tree walk.
    *