@trebco/treb 27.5.3 → 27.9.0

package/treb-calculator/src/calculator.ts

@@ -19,13 +19,13 @@
  * 
  */
 
-import type { Cell, ICellAddress, ICellAddress2, UnionValue,
-         ArrayUnion, IArea, CellDataWithAddress} from 'treb-base-types';
+import type { Cell, ICellAddress, ICellAddress2, UnionValue, EvaluateOptions,
+         ArrayUnion, IArea, CellDataWithAddress, CellValue} from 'treb-base-types';
 import { Localization, Area, ValueType, IsCellAddress} from 'treb-base-types';
          
 import type { ExpressionUnit, DependencyList, UnitRange, UnitAddress, UnitIdentifier } from 'treb-parser';
 import { Parser,
-         DecimalMarkType, ArgumentSeparatorType } from 'treb-parser';
+         DecimalMarkType, ArgumentSeparatorType, QuotedSheetNameRegex } from 'treb-parser';
 
 import { Graph } from './dag/graph';
 import type { SpreadsheetVertex } from './dag/spreadsheet_vertex';
@@ -49,10 +49,12 @@ import { Variance } from './functions/statistics-functions';
 
 import * as Primitives from './primitives';
 
-import type { DataModel, Annotation, FunctionDescriptor, Sheet } from 'treb-grid';
-import { LeafVertex } from './dag/leaf_vertex';
+import type { DataModel, Annotation, FunctionDescriptor, Sheet, ConditionalFormat } from 'treb-grid';
+import type { LeafVertex } from './dag/graph';
 
 import { ArgumentError, ReferenceError, UnknownError, ValueError, ExpressionError, NAError, DivideByZeroError } from './function-error';
+import { StateLeafVertex } from './dag/state_leaf_vertex';
+import { CalculationLeafVertex } from './dag/calculation_leaf_vertex';
 
 /**
  * breaking this out so we can use it for export (TODO)
@@ -120,27 +122,6 @@ const TranslateSubtotalType = (type: string|number): number => {
 
 };
 
-/**
- * options for the evaluate function
- */
-export interface EvaluateOptions {
-
-  /**
-   * argument separator to use when parsing input. set this option to 
-   * use a consistent argument separator independent of current locale.
-   */
-  argument_separator?: ','|';';
-
-  /** 
-   * allow R1C1-style references. the Evaluate function cannot use
-   * relative references (e.g. R[-1]C[0]), so those will always fail. 
-   * however it may be useful to use direct R1C1 references (e.g. R3C4),
-   * so we optionally support that behind this flag.
-   */
-  r1c1?: boolean;
-  
-}
-
 /**
  * we're providing a runtime option for how to handle complex numbers.
  * we will need to pass that into the calculator when it's created to
@@ -180,7 +161,11 @@ export class Calculator extends Graph {
 
   // FIXME: need a way to share/pass parser flags
 
-  public readonly parser: Parser = new Parser();
+  // public readonly parser: Parser = new Parser();
+  /** localized parser instance. we're sharing. */
+  protected get parser(): Parser {
+    return this.model.parser;
+  }
 
   protected readonly library = new FunctionLibrary();
 
@@ -192,10 +177,14 @@ export class Calculator extends Graph {
   // protected graph: Graph = new Graph(); // |null = null;
   // protected status: GraphStatus = GraphStatus.OK;
 
+  /*
   // FIXME: why is this a separate class? [actually is this a composition issue?]
   protected expression_calculator = new ExpressionCalculator(
       this.library,
       this.parser);
+    */
+
+  protected expression_calculator: ExpressionCalculator;
 
   /** the next calculation must do a full rebuild -- set on reset */
   protected full_rebuild_required = false;
@@ -204,6 +193,9 @@ export class Calculator extends Graph {
 
     super();
 
+    this.expression_calculator = new ExpressionCalculator(this.library, this.parser);
+
+
     // at the moment options are only used here; in the future
     // we may need to extend handling.
 
@@ -1298,6 +1290,7 @@ export class Calculator extends Graph {
     if (this.full_rebuild_required) {
       subset = undefined;
       this.UpdateAnnotations();
+      this.UpdateConditionals();
       // this.UpdateNotifiers();
       this.full_rebuild_required = false; // unset
     }
@@ -1380,67 +1373,11 @@ export class Calculator extends Graph {
     return map;
   }
 
-  /** wrapper method ensures it always returns an Area (instance, not interface) */
-  public ResolveArea(address: string|ICellAddress|IArea, active_sheet: Sheet): Area {
-    const resolved = this.ResolveAddress(address, active_sheet);
-    return IsCellAddress(resolved) ? new Area(resolved) : new Area(resolved.start, resolved.end);
-  }
-
-  /** 
-   * moved from embedded sheet. also modified to preserve ranges, so it
-   * might return a range (area). if you are expecting the old behavior
-   * you need to check (perhaps we could have a wrapper, or make it optional?)
-   * 
-   * Q: why does this not go in grid? or model? (...)
-   * Q: why are we not preserving absoute/relative? (...)
-   * 
-   */
-   public ResolveAddress(address: string|ICellAddress|IArea, active_sheet: Sheet): ICellAddress|IArea {
-    
-    if (typeof address === 'string') {
-      const parse_result = this.parser.Parse(address);
-      if (parse_result.expression && parse_result.expression.type === 'address') {
-        this.ResolveSheetID(parse_result.expression, undefined, active_sheet);
-        return {
-          row: parse_result.expression.row,
-          column: parse_result.expression.column,
-          sheet_id: parse_result.expression.sheet_id,
-        };
-      }
-      else if (parse_result.expression && parse_result.expression.type === 'range') {
-        this.ResolveSheetID(parse_result.expression, undefined, active_sheet);
-        return {
-          start: {
-            row: parse_result.expression.start.row,
-            column: parse_result.expression.start.column,
-            sheet_id: parse_result.expression.start.sheet_id,
-          },
-          end: {
-            row: parse_result.expression.end.row,
-            column: parse_result.expression.end.column,
-          }
-        };
-      }
-      else if (parse_result.expression && parse_result.expression.type === 'identifier') {
-
-        // is named range guaranteed to have a sheet ID? (I think yes...)
-
-        const named_range = this.model.named_ranges.Get(parse_result.expression.name);
-        if (named_range) {
-          return named_range;
-        }
-      }
-
-      return { row: 0, column: 0 }; // default for string types -- broken
-
-    }
-
-    return address; // already range or address
-
-  }
+  public Evaluate(expression: string, active_sheet?: Sheet, options?: EvaluateOptions, raw_result?: false): CellValue|CellValue[][];
+  public Evaluate(expression: string, active_sheet?: Sheet, options?: EvaluateOptions, raw_result?: true): UnionValue;
 
   /** moved from embedded sheet */
-  public Evaluate(expression: string, active_sheet?: Sheet, options: EvaluateOptions = {}) {
+  public Evaluate(expression: string, active_sheet?: Sheet, options: EvaluateOptions = {}, raw_result = false) {
     
     const current = this.parser.argument_separator;
     const r1c1_state = this.parser.flags.r1c1;
@@ -1487,13 +1424,16 @@ export class Calculator extends Graph {
             }
           }
 
-          this.ResolveSheetID(unit, undefined, active_sheet);
+          this.model.ResolveSheetID(unit, undefined, active_sheet);
         }
         return true;
       });
 
       // console.info({expression: parse_result.expression})
       const result = this.CalculateExpression(parse_result.expression);
+      if (raw_result) {
+        return result;
+      }
 
       if (result.type === ValueType.array) {
         return result.value.map(row => row.map(value => value.value));
@@ -1547,6 +1487,7 @@ export class Calculator extends Graph {
     // add leaf vertices for annotations
 
     this.UpdateAnnotations(); // all
+    this.UpdateConditionals();
 
     // and notifiers
 
@@ -1769,6 +1710,180 @@ export class Calculator extends Graph {
   }
   */
 
+  public Unresolve(ref: IArea|ICellAddress, context: Sheet, qualified = true, named = true) {
+    
+    let range = '';
+    const area = IsCellAddress(ref) ? new Area(ref) : new Area(ref.start, ref.end);
+
+    if (named) {
+      const named_range = this.model.named_ranges.MatchSelection(area);
+      if (named_range) {
+        return named_range;
+      }
+    }
+
+    if (area.count > 1) {
+      range = Area.CellAddressToLabel(area.start) + ':' + Area.CellAddressToLabel(area.end);
+    }
+    else {
+      range = Area.CellAddressToLabel(area.start);
+    }
+
+    if (!qualified) {
+      return range;
+    }
+
+    // is there a function to resolve sheet? actually, don't we know that
+    // the active selection must be on the active sheet? (...)
+
+    const sheet_id = area.start.sheet_id || context?.id;
+    const sheet_name = this.ResolveSheetName(sheet_id, true);
+
+    return sheet_name ? sheet_name + '!' + range : range;
+
+  }
+
+  /**
+   * 
+   */
+  public 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;
+    }
+    return undefined;
+  }
+
+  public RemoveConditional(conditional: ConditionalFormat): void {
+    if (conditional.type === 'expression') {
+      const vertex = conditional.internal?.vertex as LeafVertex;
+      if (vertex) {
+        vertex.Reset();
+        this.RemoveLeafVertex(vertex);
+      }
+    }
+  }
+
+  public UpdateConditionals(list?: ConditionalFormat|ConditionalFormat[], context?: Sheet): void {
+
+    if (!list) {
+      for (const sheet of this.model.sheets.list) {
+        if (sheet.conditional_formats?.length) {
+          this.UpdateConditionals(sheet.conditional_formats, sheet);
+        }
+      }
+      return;
+    }
+
+    if (!context) {
+      throw new Error('invalid call to update conditionals without context');
+    }
+
+    if (list && !Array.isArray(list)) {
+      list = [list];
+    }
+
+    for (const entry of list) {
+
+      let expression = '';
+
+      switch (entry.type) {
+        case 'cell-match':
+          expression = this.Unresolve(entry.area, context, true, false) + ' ' + entry.expression;
+          break;
+
+        case 'expression':
+          expression = entry.expression;
+          break;
+
+        case 'duplicate-values':
+          expression = `UniqueValues(${
+            this.Unresolve(entry.area, context, true, false)
+          })`;
+          if (!entry.unique) {
+            expression = `NOT(${expression})`;
+          }
+          break;
+
+        case 'gradient':
+          expression = `=Gradient(${
+            [
+              this.Unresolve(entry.area, context, true, false),
+              entry.min ?? '',
+              entry.max ?? '',
+
+            ].join(this.parser.argument_separator)
+          })`;
+          break;
+
+        default:
+          continue;
+      }
+
+      if (!expression) {
+        continue; // FIXME: warn?
+      }
+
+      // console.info({type: entry.type, expression});
+
+      if (!entry.internal) {
+        entry.internal = {};
+      }
+      if (!entry.internal.vertex) {
+        entry.internal.vertex = new CalculationLeafVertex();
+
+        let options: EvaluateOptions|undefined;
+        if (entry.type !== 'gradient' && entry.type !== 'duplicate-values') {
+          options = entry.options;
+        }
+
+        // first pass, run the calculation
+        const check = this.Evaluate(expression, context, options, true);
+        entry.internal.vertex.result = check;
+        entry.internal.vertex.updated = true;
+
+      }
+
+      const vertex = entry.internal.vertex as LeafVertex;
+      this.AddLeafVertex(vertex);
+      this.UpdateLeafVertex(vertex, expression, context);
+
+      /*
+      if (entry.type === 'cell-match') {
+        if (!entry.internal) {
+          entry.internal = {};
+        }
+        if (!entry.internal.vertex) {
+          entry.internal.vertex = new CalculationLeafVertex();
+        }
+        const vertex = entry.internal.vertex as LeafVertex;
+        this.AddLeafVertex(vertex);
+        this.UpdateLeafVertex(vertex, entry.expression, context);
+      }
+      else if (entry.type === 'expression') {
+        if (!entry.internal) {
+          entry.internal = {};
+        }
+        if (!entry.internal.vertex) {
+          entry.internal.vertex = new CalculationLeafVertex();
+
+          // set initial state based on current state
+          entry.internal.vertex.result = { type: ValueType.boolean, value: !!entry.applied };
+
+        }
+        const vertex = entry.internal.vertex as LeafVertex;
+        this.AddLeafVertex(vertex);
+        this.UpdateLeafVertex(vertex, entry.expression, context);
+      }
+      */
+
+    }
+
+  }
+
   public RemoveAnnotation(annotation: Annotation): void {
     const vertex = (annotation.temp.vertex as LeafVertex);
     if (!vertex) { return; }
@@ -1803,7 +1918,7 @@ export class Calculator extends Graph {
     for (const entry of list) {
       if (entry.data.formula) {
         if (!entry.temp.vertex) {
-          entry.temp.vertex = new LeafVertex();
+          entry.temp.vertex = new StateLeafVertex();
         }
         const vertex = entry.temp.vertex as LeafVertex;
         this.AddLeafVertex(vertex);
@@ -1813,48 +1928,6 @@ export class Calculator extends Graph {
 
   }
 
-  /**
-   * returns false if the sheet cannot be resolved, which probably
-   * means the name changed (that's the case we are working on with
-   * this fix).
-   */
-  public ResolveSheetID(expr: UnitAddress|UnitRange, context?: ICellAddress, active_sheet?: Sheet): boolean {
-
-    const target = expr.type === 'address' ? expr : expr.start;
-
-    if (target.sheet_id) {
-      return true;
-    }
-
-    if (target.sheet) {
-      const sheet = this.model.sheets.Find(target.sheet);
-      if (sheet) {
-        target.sheet_id = sheet.id;
-        return true;
-      }
-
-      /*
-      const lc = target.sheet.toLowerCase();
-      for (const sheet of this.model.sheets.list) {
-        if (sheet.name.toLowerCase() === lc) {
-          target.sheet_id = sheet.id;
-          return true;
-        }
-      }
-      */
-    }
-    else if (context?.sheet_id) {
-      target.sheet_id = context.sheet_id;
-      return true;
-    }
-    else if (active_sheet?.id) {
-      target.sheet_id = active_sheet.id;
-      return true;
-    }
-
-    return false; // the error
-
-  }
 
   // --- protected -------------------------------------------------------------
 
@@ -1866,13 +1939,13 @@ export class Calculator extends Graph {
 
     switch (expr.type) {
       case 'address':
-        if (this.ResolveSheetID(expr, context)) {
+        if (this.model.ResolveSheetID(expr, context)) {
           return new Area(expr);
         }
         break;
 
       case 'range':
-        if (this.ResolveSheetID(expr, context)) {
+        if (this.model.ResolveSheetID(expr, context)) {
           return new Area(expr.start, expr.end);
         }
         break;

package/treb-calculator/src/dag/calculation_leaf_vertex.ts

@@ -0,0 +1,97 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+import type { GraphCallbacks } from './spreadsheet_vertex_base';
+import { SpreadsheetVertex } from './spreadsheet_vertex';
+import type { Vertex} from './vertex';
+import { Color } from './vertex';
+
+/**
+ * adding a new leaf vertex type that actually does a calculation;
+ * but it has no spreadsheet context (address) and by definition it 
+ * has no dependendents.
+ * 
+ * this is intended for managing conditional formats, if they have
+ * an expression. we only want to calculate these when necessary 
+ * (i.e. dependencies have updated, or they are volatile). 
+ * 
+ */ 
+export class CalculationLeafVertex extends SpreadsheetVertex {
+
+  public static type = 'calculation-leaf-vertex';
+
+  public type = CalculationLeafVertex.type; // for type guard
+  
+  public address = { row: -1, column: -1 }; // fake address
+
+  /** 
+   * flag, to reduce unecessary application. work in progress. this
+   * indicates that we reached the calculation step. that means either
+   * (1) dependencies changed, or (2) we were marked dirty in some global
+   * operation, probably a full-recalc. 
+   * 
+   * (2) is a waste but we're still going to save some cycles here. if you
+   * want you could add a state check like the other leaf vertex.
+   */
+  public updated = false;
+
+  /**
+   * leaf vertex defaults to black (i.e. tested) because leaf nodes cannot have 
+   * outbound edges. it is still possible to change this, because it's a property 
+   * and we can't override the set accessor, but making it an accessor in the 
+   * superclass just for this purpose is not worthwhile since regular vertices 
+   * should vastly outnumber leaves.
+   */
+  public color = Color.black;
+
+  /** overrides calculate function */
+  public Calculate(graph: GraphCallbacks): void {
+
+    // if we are not dirty, nothing to do
+    if (!this.dirty) return;
+
+    // check deps
+    for (const edge of this.edges_in) {
+      if ((edge as SpreadsheetVertex).dirty) {
+        return;
+      }
+    }
+
+    // ...
+
+    const result = graph.CalculationCallback.call(graph, this);
+
+    this.result = result.value;
+    this.dirty = false;
+
+    // set flag
+
+    this.updated = true;
+
+    // we are not allowed to have edges out, so nothing to do
+
+  }
+
+  public AddDependent(edge: Vertex): void {
+    throw(new Error('leaf vertex cannot have dependents'));
+  }
+
+}

package/treb-calculator/src/dag/graph.ts

@@ -24,10 +24,13 @@ import { Color } from './vertex';
 import { SpreadsheetVertex  } from './spreadsheet_vertex';
 import { ArrayVertex  } from './array-vertex';
 import type { SpreadsheetVertexBase, CalculationResult, GraphCallbacks } from './spreadsheet_vertex_base';
-import type { LeafVertex } from './leaf_vertex';
+import type { StateLeafVertex } from './state_leaf_vertex';
 import type { ICellAddress, ICellAddress2, IArea, UnionValue } from 'treb-base-types';
 import { Area } from 'treb-base-types';
 import type { DataModel } from 'treb-grid';
+import { CalculationLeafVertex } from './calculation_leaf_vertex';
+
+export type LeafVertex = StateLeafVertex|CalculationLeafVertex;
 
 // FIXME: this is a bad habit if you're testing on falsy for OK.
 
@@ -61,7 +64,8 @@ export abstract class Graph implements GraphCallbacks {
   public loop_hint?: string;
 
   // special
-  public leaf_vertices: LeafVertex[] = [];
+  // public leaf_vertices: LeafVertex[] = [];
+  public leaf_vertices: Set<LeafVertex> = new Set();
 
   /** lock down access */
   private dirty_list: SpreadsheetVertexBase[] = [];
@@ -102,7 +106,7 @@ export abstract class Graph implements GraphCallbacks {
     this.dirty_list = [];
     this.volatile_list = [];
     this.vertices = [[]];
-    this.leaf_vertices = [];
+    this.leaf_vertices.clear(); 
     // this.cells_map = {};
 
     /** array vertex maintains its own list */
@@ -812,28 +816,12 @@ export abstract class Graph implements GraphCallbacks {
    * managing and maintaining these vertices: we only need references.
    */
   public AddLeafVertex(vertex: LeafVertex): void {
-
-    // ... don't add more than once. this is expensive but
-    // the list should (generally speaking) be short, so not
-    // a serious problem atm
-
-    /*
-    if (this.leaf_vertices.some((test) => test === vertex)) {
-      return;
-    }
-    */
-   for (const test of this.leaf_vertices) {
-     if (test === vertex) {
-       return;
-     }
-   }
-
-    this.leaf_vertices.push(vertex);
+    this.leaf_vertices.add(vertex); 
   }
 
-  /** removes vertex, by match */
+  /** removes vertex */
   public RemoveLeafVertex(vertex: LeafVertex): void {
-    this.leaf_vertices = this.leaf_vertices.filter((test) => test !== vertex);
+    this.leaf_vertices.delete(vertex);
   }
 
   /**

package/treb-calculator/src/dag/{leaf_vertex.ts → state_leaf_vertex.ts}

@@ -40,12 +40,12 @@ import { Color } from './vertex';
  * have both leaf- and spreadsheet-vertex extend that.
  *
  */
-export class LeafVertex extends SpreadsheetVertex {
+export class StateLeafVertex extends SpreadsheetVertex {
 
-  public static type = 'leaf-vertex';
+  public static type = 'state-leaf-vertex';
 
   public state_id = 0;
-  public type = LeafVertex.type; // for type guard
+  public type = StateLeafVertex.type; // for type guard
   
   /**
    * leaf vertex defaults to black (i.e. tested) because leaf nodes cannot have 

package/treb-calculator/src/descriptors.ts

@@ -112,10 +112,17 @@ export interface CompositeFunctionDescriptor {
   fn: (...args: any[]) => UnionValue; // UnionOrArray; // |UnitAddress|UnitRange;
 
   /**
-   * for the future. some functions should not be available in
-   * spreadsheet cells (charts, basically)
+   * limited visibility
+   * 
+   * internal functions do not show up in the spreadsheet. we have an 
+   * annotation value which should be usef in the future but it's not 
+   * implemented yet.
+   * 
+   * should we allow these functions to be used, and just not tooltip them;
+   * or block them entirely? for now we'll do the former as it's helpful to 
+   * defug.
    */
-  visibility?: string;
+  visibility?: 'internal'|'annotation';
 
   /**
    * for the future

package/treb-calculator/src/expression-calculator.ts

@@ -821,7 +821,7 @@ export class ExpressionCalculator {
     const value: UnionValue[][] = [];
 
     for (let c = 0; c < columns; c++) {
-      const col = [];
+      const col: UnionValue[] = [];
       for (let r = 0; r < rows; r++ ) {
         col[r] = fn(left_values[c][r], right_values[c][r]);
       }