@trebco/treb 27.7.6 → 27.9.0

package/treb-embed/src/embedded-spreadsheet.ts

@@ -32,33 +32,47 @@ import type {
   AnnotationViewData,
   AnnotationType, 
   ExternalEditorConfig,
+  ConditionalFormatDuplicateValuesOptions,
+  ConditionalFormatDuplicateValues,
+  ConditionalFormatGradientOptions,
+  ConditionalFormat, 
+  ConditionalFormatGradient, 
+  ConditionalFormatExpression,
+  StandardGradient,
+  CondifionalFormatExpressionOptions,
+  ConditionalFormatCellMatchOptions,
+  ConditionalFormatCellMatch,
 } from 'treb-grid';
 
 import {
-  DataModel, Grid, BorderConstants, Sheet, ErrorCode, UA
+  DataModel, Grid, BorderConstants, Sheet, ErrorCode, UA,
+  StandardGradientsList,
 } from 'treb-grid';
 
 import { 
   Parser, DecimalMarkType, 
   ArgumentSeparatorType, QuotedSheetNameRegex } from 'treb-parser';
 
-import { Calculator, type EvaluateOptions, type LeafVertex } from 'treb-calculator';
+import { Calculator, type LeafVertex } from 'treb-calculator';
 
 import type {
   ICellAddress, 
+  EvaluateOptions,
   IArea, CellValue, Point,
   Complex, ExtendedUnion, IRectangle,
-  AddressReference, RangeReference, TableSortOptions, Table, TableTheme,
+  AddressReference, RangeReference, TableSortOptions, Table, TableTheme, GradientStop,
 } from 'treb-base-types';
 
 import {
   IsArea, ThemeColorTable, ComplexToString, Rectangle, IsComplex, type CellStyle,
-  Localization, Style, type Color, ThemeColor2, IsCellAddress, Area, IsFlatData, IsFlatDataArray, 
+  Localization, Style, type Color, ThemeColor2, IsCellAddress, Area, IsFlatData, IsFlatDataArray, Gradient, ValueType, 
 } from 'treb-base-types';
 
 import { EventSource, Yield, ValidateURI } from 'treb-utils';
 import { NumberFormatCache, ValueParser, NumberFormat } from 'treb-format';
 
+
+
 // --- local -------------------------------------------------------------------
 
 import { Dialog, DialogType } from './progress-dialog';
@@ -81,6 +95,7 @@ import type { SetRangeOptions } from 'treb-grid';
  * the script so we can run it as a worker.
  */
 import * as export_worker_script from 'worker:../../treb-export/src/export-worker/index.worker';
+import { StateLeafVertex } from 'treb-calculator/src/dag/state_leaf_vertex';
 
 // --- types -------------------------------------------------------------------
 
@@ -1251,6 +1266,265 @@ export class EmbeddedSpreadsheet {
 
   }
 
+  //////////////////////////////////////////////////////////////////////////////
+  //
+  // conditional formatting API (WIP)
+  //
+
+  /**
+   * list conditional formats. uses the active sheet by default, or pass a 
+   * sheet name or id.
+   * 
+   * @internal
+   */
+  public ListConditionalFormats(sheet?: number|string) {
+
+    const target = (typeof sheet === 'undefined') ? 
+      this.grid.active_sheet :
+      this.model.sheets.Find(sheet);
+
+    return target?.conditional_formats || [];
+      
+  }
+
+  /** @internal */
+  public ConditionalFormatDuplicateValues(range: RangeReference|undefined, options: ConditionalFormatDuplicateValuesOptions): ConditionalFormat {
+       
+    if (range === undefined) {
+      const ref = this.GetSelectionReference();
+      if (ref.empty) {
+        throw new Error('invalid range (no selection)');
+      }
+      range = ref.area;
+    }
+    
+    return this.AddConditionalFormat({
+        type: 'duplicate-values',
+        area: this.model.ResolveArea(range, this.grid.active_sheet),
+        ...options,
+      });
+
+  }
+
+  /**
+   * @internal
+   */
+  public ConditionalFormatGradient(range: RangeReference|undefined, options: ConditionalFormatGradientOptions|StandardGradient): ConditionalFormat {
+
+    if (range === undefined) {
+      const ref = this.GetSelectionReference();
+      if (ref.empty) {
+        throw new Error('invalid range (no selection)');
+      }
+      range = ref.area;
+    }
+    
+    const area = this.model.ResolveArea(range, this.grid.active_sheet);
+
+    const format: ConditionalFormatGradient = (typeof options === 'object') ?
+      {
+        type: 'gradient', area, ...options,
+      } :
+      {
+        type: 'gradient', area, ...StandardGradientsList[options]
+      };
+
+    this.AddConditionalFormat(format);
+    return format;
+
+  }
+
+  /** @internal */
+  public ConditionalFormatCellMatch(range: RangeReference|undefined, options: ConditionalFormatCellMatchOptions): ConditionalFormat {
+
+    if (range === undefined) {
+      const ref = this.GetSelectionReference();
+      if (ref.empty) {
+        throw new Error('invalid range (no selection)');
+      }
+      range = ref.area;
+    }
+    
+    const area = this.model.ResolveArea(range, this.grid.active_sheet);
+
+    const format: ConditionalFormatCellMatch = {
+      type: 'cell-match',
+      area,
+      ...options,
+    };
+
+    // we need to calculate the formula once, to get an initial state
+    // update: internal
+    // let result = this.Evaluate(this.Unresolve(area, true, false) + ' ' + options.expression, options.options);
+
+    // ... apply ...
+
+    this.AddConditionalFormat(format);
+    return format;
+
+
+  }
+
+  /**
+   * @internal
+   */
+  public ConditionalFormatExpression(range: RangeReference|undefined, options: CondifionalFormatExpressionOptions): ConditionalFormat {
+
+    if (range === undefined) {
+      const ref = this.GetSelectionReference();
+      if (ref.empty) {
+        throw new Error('invalid range (no selection)');
+      }
+      range = ref.area;
+    }
+    
+    const area = this.model.ResolveArea(range, this.grid.active_sheet);
+
+    const format: ConditionalFormatExpression = {
+      type: 'expression',
+      area,
+      ...options,
+    };
+
+    /*
+    // we need to calculate the formula once, to get an initial state
+    let result = this.Evaluate(options.expression, options.options);
+
+    if (Array.isArray(result)) {
+      result = result[0][0];
+    }
+    const applied = !!result;
+    
+    this.AddConditionalFormat({...format, applied });
+    */
+
+    this.AddConditionalFormat(format);
+
+    return format;
+
+  }
+
+  /**
+   * add a conditional format
+   * 
+   * @internal
+   */
+  public AddConditionalFormat(format: ConditionalFormat) {
+
+    const sheet = this.model.sheets.Find(format.area.start.sheet_id||0);
+    
+    if (!sheet) {
+      throw new Error('invalid reference in format');
+    }
+
+    sheet.conditional_formats.push(format);
+
+    this.calculator.UpdateConditionals(format, sheet);
+
+    // call update if it's the current sheet
+    this.ApplyConditionalFormats(sheet, sheet === this.grid.active_sheet);
+
+    this.PushUndo();
+
+    // fluent
+    return format;
+
+  }
+
+  /**
+   * remove conditional format
+   * 
+   * @internal
+   */
+  public RemoveConditionalFormat(format: ConditionalFormat) {
+    const area = format.area;
+    const sheet = area.start.sheet_id ? this.model.sheets.Find(area.start.sheet_id) : this.grid.active_sheet;
+
+    if (!sheet) {
+      throw new Error('invalid reference in format');
+    }
+
+    let count = 0;
+    sheet.conditional_formats = sheet.conditional_formats.filter(test => {
+      if (test === format) {
+        count++;
+        this.calculator.RemoveConditional(test);
+        return false;
+      }
+      return true;
+    });
+
+    if (count) {
+      sheet.FlushConditionalFormats();
+    }
+
+    // we want to call update if it's the current sheet,
+    // but we want a full repaint
+
+    this.ApplyConditionalFormats(sheet, false);
+
+    if (sheet === this.grid.active_sheet) {
+      this.grid.Update(true);
+    }
+
+    if (count) {
+      this.PushUndo();
+    }
+
+  }
+
+  /**
+   * clear conditional formats from the target range (or currently selected
+   * range). we operate on format objects, meaning we'll remove the whole
+   * format object rather than clip the area.
+   * 
+   * @internal
+   */
+  public RemoveConditionalFormats(range?: RangeReference) {
+
+    if (range === undefined) {
+      const ref = this.GetSelectionReference();
+      if (ref.empty) {
+        throw new Error('invalid range (no selection)');
+      }
+      range = ref.area;
+    }
+    const area = this.model.ResolveArea(range, this.grid.active_sheet);
+    const sheet = area.start.sheet_id ? this.model.sheets.Find(area.start.sheet_id) : this.grid.active_sheet;
+
+    if (sheet) {
+      let count = 0;
+
+      sheet.conditional_formats = sheet.conditional_formats.filter(test => {
+        const compare = new Area(test.area.start, test.area.end);
+        if (compare.Intersects(area)) {
+          count++;
+          this.calculator.RemoveConditional(test);
+          return false;
+        }
+        return true;
+      });
+
+      if (count) {
+
+        sheet.FlushConditionalFormats();
+
+        this.ApplyConditionalFormats(sheet, false);
+    
+        if (sheet === this.grid.active_sheet) {
+          this.grid.Update(true);
+        }
+
+        this.PushUndo();
+      }
+
+    }
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
   /**
    * @internal
    */
@@ -1794,6 +2068,19 @@ export class EmbeddedSpreadsheet {
 
     this.UpdateDocumentStyles();
 
+    // we need to flush conditional formats that use theme colors
+    // (I guess we're just flushing everybody?)
+
+    for (const sheet of this.model.sheets.list) {
+      for (const format of sheet.conditional_formats) {
+        format.internal = undefined;
+      }
+    }
+
+    this.calculator.UpdateConditionals();
+    this.ApplyConditionalFormats(this.grid.active_sheet, false);
+    this.grid.Update(true);
+
   }
 
   /**
@@ -2954,11 +3241,11 @@ export class EmbeddedSpreadsheet {
     // FIXME: optional? parameter? (...)
 
     if (data.rendered_values && !options.recalculate) {
-      this.grid.Update();
       this.calculator.RebuildClean(true);
+      this.ApplyConditionalFormats(this.grid.active_sheet, false);
+      this.grid.Update();
     }
     else {
-      // console.info('load recalc');
       this.Recalculate();
     }
 
@@ -3248,6 +3535,7 @@ export class EmbeddedSpreadsheet {
     }
 
     this.calculator.Calculate(area);
+    this.ApplyConditionalFormats(this.grid.active_sheet, false);
 
     this.grid.Update(true); // , area);
     this.UpdateAnnotations();
@@ -3432,6 +3720,9 @@ export class EmbeddedSpreadsheet {
       ref = resolved;
     }
 
+    return this.calculator.Unresolve(ref, this.grid.active_sheet, qualified, named);
+
+    /*
     let range = '';
     const area = IsCellAddress(ref) ? new Area(ref) : new Area(ref.start, ref.end);
 
@@ -3457,10 +3748,11 @@ export class EmbeddedSpreadsheet {
     // the active selection must be on the active sheet? (...)
 
     const sheet_id = area.start.sheet_id || this.grid.active_sheet.id;
-    const sheet_name = this.ResolveSheetName(sheet_id, true);
+    const sheet_name = this.calculator.ResolveSheetName(sheet_id, true);
 
     return sheet_name ? sheet_name + '!' + range : range;
-    
+    */
+
   }
   
   /**
@@ -3482,7 +3774,7 @@ export class EmbeddedSpreadsheet {
 
     return this.calculator.Evaluate(
         expression, this.grid.active_sheet, options);
-
+   
   }
 
   /**
@@ -3522,7 +3814,7 @@ export class EmbeddedSpreadsheet {
     // the active selection must be on the active sheet? (...)
 
     const sheet_id = ref.area.start.sheet_id || this.grid.active_sheet.id;
-    const sheet_name = this.ResolveSheetName(sheet_id, true);
+    const sheet_name = this.calculator.ResolveSheetName(sheet_id, true);
 
     return sheet_name ? sheet_name + '!' + range : range;
 
@@ -3940,6 +4232,47 @@ export class EmbeddedSpreadsheet {
 
   // --- internal (protected) methods ------------------------------------------
 
+  /**
+   * 
+   */
+  protected ApplyConditionalFormats(sheet: Sheet, call_update: boolean) {
+
+    // const sheet = this.grid.active_sheet;
+    const areas: IArea[] = [];
+
+    if (sheet.conditional_formats.length || sheet.flush_conditional_formats) {
+
+      for (const entry of sheet.conditional_formats) {
+        areas.push(entry.area);
+
+        // NOTE: we're (optionally) adding the gradient here, instead
+        // of when it's created, because we might want to flush this
+        // from time to time. specifically, because gradient might use
+        // theme colors, we need to flush it when the theme is updated.
+
+        // so don't move it, even though it is tempting. or rewrite to 
+        // update on theme changes.
+
+        if (entry.type === 'gradient') {
+          if (!entry.internal) {
+            entry.internal = {};
+          }
+          if (!entry.internal.gradient) {
+            entry.internal.gradient = new Gradient(entry.stops, this.grid.theme, entry.color_space);
+          }
+        }
+      }
+
+      sheet.ApplyConditionalFormats();
+
+    }
+
+    if (call_update) {
+      this.grid.Update(true, areas);
+    }
+
+  }
+
   protected ResolveTable(reference: RangeReference): Table|undefined {
 
     let table: Table|undefined = undefined;
@@ -4044,6 +4377,11 @@ export class EmbeddedSpreadsheet {
 
             this.InflateAnnotations();
 
+            // and conditional formats
+
+            this.calculator.UpdateConditionals();
+            this.ApplyConditionalFormats(this.grid.active_sheet, false);
+            
           }
           else {
             return reject('unknown error (missing data)');
@@ -4164,6 +4502,9 @@ export class EmbeddedSpreadsheet {
 
     this.UpdateAnnotations();
 
+    this.calculator.UpdateConditionals();
+    this.ApplyConditionalFormats(event.activate, true);
+
   }
 
   protected HandleDrag(event: DragEvent): void {
@@ -4556,7 +4897,7 @@ export class EmbeddedSpreadsheet {
   protected UpdateAnnotations(): void {
     for (const annotation of this.grid.active_sheet.annotations) {
       if (annotation.temp.vertex) {
-        const vertex = annotation.temp.vertex as LeafVertex;
+        const vertex = annotation.temp.vertex as StateLeafVertex;
         if (vertex.state_id !== annotation.temp.state) {
           annotation.temp.state = vertex.state_id;
 
@@ -5436,35 +5777,5 @@ export class EmbeddedSpreadsheet {
     }
   }
 
-  /**
-   * this is only used in one place, can we just inline?
-   * [A: seems like it might be useful, though]
-   * 
-   * @param id 
-   * @param quote 
-   * @returns 
-   */
-  protected ResolveSheetName(id: number, quote = false): string | undefined {
-    const sheet = this.model.sheets.Find(id);
-    if (sheet) {
-      if (quote && QuotedSheetNameRegex.test(sheet.name)) {
-        return `'${sheet.name}'`;
-      }
-      return sheet.name;
-    }
-
-    /*
-    for (const sheet of this.grid.model.sheets) {
-      if (sheet.id === id) {
-        if (quote && QuotedSheetNameRegex.test(sheet.name)) {
-          return `'${sheet.name}'`;
-        }
-        return sheet.name;
-      }
-    }
-    */
-
-    return undefined;
-  }
 
 }

package/treb-export/src/export-worker/export-worker.ts

@@ -40,19 +40,6 @@ const ExportSheets = async (data: any) => {
     ctx.postMessage({ status: 'complete', blob: corrected });
   }
 
-  /*
-  if (data.sheet) {
-    await exporter.Init();
-    await exporter.ExportSheets(data.sheet);
-    const blob = await exporter.AsBlob(1);
-
-    // correct the mime type for firefox
-    const corrected = (blob as Blob).slice(0, (blob as Blob).size,
-      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
-
-    ctx.postMessage({ status: 'complete', blob: corrected });
-  }
-  */
 };
 
 const ImportSheet = async (data: any) => {