@trebco/treb 27.7.6 → 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
@@ -1309,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
     }
@@ -1391,9 +1373,11 @@ export class Calculator extends Graph {
     return map;
   }
 
+  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;
@@ -1447,6 +1431,9 @@ export class Calculator extends Graph {
 
       // 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));
@@ -1500,6 +1487,7 @@ export class Calculator extends Graph {
     // add leaf vertices for annotations
 
     this.UpdateAnnotations(); // all
+    this.UpdateConditionals();
 
     // and notifiers
 
@@ -1722,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; }
@@ -1756,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);

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]);
       }

package/treb-calculator/src/function-library.ts

@@ -1,24 +1,24 @@
-/*
- * 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
- * 
- */
-
+/*
+ * 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 { 
   ExtendedFunctionDescriptor, CompositeFunctionDescriptor,
   FunctionMap, ExtendedFunctionMap } from './descriptors';
@@ -80,9 +80,12 @@ export class FunctionLibrary {
   }
 
   /** get a list, for AC services */
-  public List() {
+  public List(filter_internal = true) {
     const list: ExtendedFunctionMap = {};
     for (const key of Object.keys(this.functions)) {
+      if (filter_internal && this.functions[key].visibility === 'internal') {
+        continue;
+      }
       list[key] = this.functions[key];
     }
     return list;