@trebco/treb 28.17.5 → 29.1.4

package/treb-calculator/src/calculator.ts

@@ -24,8 +24,7 @@ import type { Cell, ICellAddress, ICellAddress2, UnionValue, EvaluateOptions,
 import { Localization, Area, ValueType, IsCellAddress} from 'treb-base-types';
          
 import type { ExpressionUnit, DependencyList, UnitRange, UnitAddress, UnitIdentifier, ParseResult } from 'treb-parser';
-import { Parser,
-         DecimalMarkType, ArgumentSeparatorType, QuotedSheetNameRegex } from 'treb-parser';
+import { Parser, DecimalMarkType, QuotedSheetNameRegex } from 'treb-parser';
 
 import { Graph } from './dag/graph';
 import type { SpreadsheetVertex } from './dag/spreadsheet_vertex';
@@ -35,7 +34,7 @@ import { ExpressionCalculator, UnionIsMetadata } from './expression-calculator';
 import * as Utilities from './utilities';
 
 import { FunctionLibrary } from './function-library';
-import type { FunctionMap} from './descriptors';
+import type { FunctionMap } from './descriptors';
 import { ReturnType } from './descriptors';
 import { AltFunctionLibrary, BaseFunctionLibrary } from './functions/base-functions';
 import { FinanceFunctionLibrary } from './functions/finance-functions';
@@ -49,13 +48,15 @@ import { Variance } from './functions/statistics-functions';
 
 import * as Primitives from './primitives';
 
-import type { DataModel, Annotation, FunctionDescriptor, Sheet, ConditionalFormat } from 'treb-grid';
+import type { FunctionDescriptor } 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';
-import type { ConnectedElementType } from 'treb-grid';
+
+import { Sheet } from 'treb-data-model';
+import type { Annotation, DataModel, ConnectedElementType, ConditionalFormat } from 'treb-data-model';
 
 import { ValueParser } from 'treb-format';
 
@@ -162,10 +163,10 @@ const default_calculator_options: CalculatorOptions = {
  */
 export class Calculator extends Graph {
 
-  // FIXME: need a way to share/pass parser flags
-
-  // public readonly parser: Parser = new Parser();
-  /** localized parser instance. we're sharing. */
+  /** 
+   * localized parser instance. we're sharing. 
+   * FIXME: remove local references so we can remove this accessor 
+   */
   protected get parser(): Parser {
     return this.model.parser;
   }
@@ -174,19 +175,6 @@ export class Calculator extends Graph {
 
   protected registered_libraries: Record<string, boolean> = {};
 
-//  protected notifier_id_source = 100;
-//  protected notifiers: InternalNotifierType[] = [];
-
-  // 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 */
@@ -255,7 +243,7 @@ export class Calculator extends Graph {
       return result;
     };
 
-    const CountIfInternal = (range: any, criteria: any): UnionValue => {
+    const CountIfInternal = (range: CellValue[][], criteria: CellValue): UnionValue => {
 
       // do we really need parser/calculator for this? I think
       // we've maybe gone overboard here, could we just use valueparser
@@ -263,7 +251,7 @@ export class Calculator extends Graph {
       // in any event there are no dynamic dependencies with this 
       // function.
 
-      const data = Utilities.FlattenUnboxed(range);
+      const data = Utilities.FlattenCellValues(range);
 
       let parse_result: ParseResult|undefined;
       let expression: ExpressionUnit|undefined;
@@ -318,7 +306,7 @@ export class Calculator extends Graph {
             }
 
             if (expression?.type === 'call' && expression.args[0]?.type === 'array') {
-              expression.args[0].values = [data];
+              expression.args[0].values = [Utilities.FilterIntrinsics(data)];
             }
 
           }
@@ -369,7 +357,7 @@ export class Calculator extends Graph {
           }
         }
 
-        expression.left.values = [data];
+        expression.left.values = [Utilities.FilterIntrinsics(data)];
 
       }
 
@@ -410,7 +398,7 @@ export class Calculator extends Graph {
           { name: 'type' },
           { name: 'range', metadata: true, }
         ],
-        fn: (type: number|string, ...args: any[]): UnionValue => {
+        fn: (type: number|string, ...args: UnionValue[]): UnionValue => {
 
           type = TranslateSubtotalType(type);
 
@@ -447,7 +435,8 @@ export class Calculator extends Graph {
 
             // where is the metadata type? sigh
 
-            const address = (entry.value?.address) as UnitAddress;
+            const address = ((entry.value as {address?: UnitAddress})?.address) as UnitAddress;
+
             if (!address) {
               return ReferenceError();
             }
@@ -472,7 +461,7 @@ export class Calculator extends Graph {
               continue;
             }
 
-            const entry_value = entry.value?.value;
+            const entry_value = (entry.value as {value?: CellValue})?.value;
 
             // counta includes empty strings
 
@@ -575,7 +564,7 @@ export class Calculator extends Graph {
 
           let count = 0;
 
-          let result = CountIfInternal(args[0], args[1]);
+          const result = CountIfInternal(args[0], args[1]);
           if (result.type !== ValueType.array) {
             return result; // error
           }
@@ -753,7 +742,7 @@ export class Calculator extends Graph {
         ],
         return_type: ReturnType.reference,
         volatile: true, // necessary?
-        fn: ((reference: string) => {
+        fn: ((reference: string): UnionValue => {
 
           if (!reference || (typeof reference !== 'string')) {
             return ArgumentError();
@@ -780,7 +769,7 @@ export class Calculator extends Graph {
             return { type: ValueType.undefined, value: undefined };
           }
 
-          return { type: ValueType.object, value: parse_result.expression as any };
+          return { type: ValueType.object, value: parse_result.expression };
 
         }).bind(this),
 
@@ -960,13 +949,18 @@ export class Calculator extends Graph {
       },
 
 
-  /** not sure when this one appeared, but it's what I was looking for */
+      /** 
+       * not sure when this one appeared, but it's what I was looking for 
+       * 
+       * ---
+       * what an odd comment. what does that mean? 
+       */
       FormulaText: {
         description: 'Returns a formula as a string',
         arguments: [
-          { name: 'reference', description: 'Cell reference', metadata: true, },
+          { name: 'reference', description: 'Cell reference', metadata: true, unroll: true },
         ],
-        fn: Utilities.ApplyAsArray((reference: UnionValue): UnionValue => {
+        fn: (reference: UnionValue): UnionValue => {
 
           if (!UnionIsMetadata(reference)) {
             return ReferenceError();
@@ -983,7 +977,7 @@ export class Calculator extends Graph {
           
           return ReferenceError();
 
-        }),
+        },
       },
 
       /**
@@ -994,16 +988,19 @@ export class Calculator extends Graph {
         description: 'Returns true if the reference is a formula',
         arguments: [{
           name: 'Reference',
+          unroll: true,
           metadata: true, /* OK with array metadata */
         }],
-        fn: Utilities.ApplyAsArray((ref: UnionValue): UnionValue => {
+        fn: (ref: UnionValue): UnionValue => {
 
           // this is wasteful because we know that the range will all
           // be in the same sheet... we don't need to look up every time
 
-          const sheet = this.model.sheets.Find(ref?.value?.address?.sheet_id || 0);
-          if (sheet) {
-            const cell = sheet.cells.GetCell(ref.value.address, false);
+          const addr = (ref?.value as {address?: UnitAddress})?.address;
+
+          const sheet = this.model.sheets.Find(addr?.sheet_id || 0);
+          if (addr && sheet) {
+            const cell = sheet.cells.GetCell(addr, false);
             return { 
               type: ValueType.boolean, 
               value: cell?.type === ValueType.formula,
@@ -1014,7 +1011,7 @@ export class Calculator extends Graph {
             type: ValueType.boolean, value: false,
           };
 
-        }),
+        },
       },
 
     });
@@ -1031,7 +1028,7 @@ export class Calculator extends Graph {
    * values to followers.
    */
   public ExportCalculatedValues(): Record<number, CellDataWithAddress[]> {
-    const data: any = {};
+    const data: Record<number, CellDataWithAddress[]> = {};
     for (const sheet of this.model.sheets.list) {
       const calculated = sheet.cells.toJSON({calculated_value: true}).data as CellDataWithAddress[];
       data[sheet.id] = calculated.filter(test => test.calculated !== undefined);
@@ -1098,7 +1095,39 @@ export class Calculator extends Graph {
           if (values[row]) {
             let column = 0;
             for (; column < columns && column < values[row].length; column++) {
-              cells.data[row + area.start.row][column + area.start.column].SetCalculatedValue(values[row][column].value, values[row][column].type);
+
+              // if there's a nested array, take the first value. but
+              // don't recurse; if there's another array in there set
+              // as undefined (should be error?)
+
+              let indexed_value = values[row][column];
+              if (indexed_value.type === ValueType.array) {
+                indexed_value = indexed_value.value[0][0];
+              }
+
+              switch (indexed_value.type) {
+                case ValueType.array:
+                case ValueType.object:
+                  cells.data[row + area.start.row][column + area.start.column].SetCalculatedValue(undefined); // error?
+                    break;
+
+                default:
+                  cells.data[row + area.start.row][column + area.start.column].SetCalculatedValue(
+                    indexed_value.value, indexed_value.type);
+  
+              }
+             
+              /*
+              if (indexed_value.type !== ValueType.object) {
+                cells.data[row + area.start.row][column + area.start.column].SetCalculatedValue(
+                  indexed_value.value, indexed_value.type);
+              }
+
+              cells.data[row + area.start.row][column + area.start.column].SetCalculatedValue(
+                values[row][column].value, 
+                values[row][column].type);
+                */
+
             }
             for (; column < columns; column++) {
               cells.data[row + area.start.row][column + area.start.column].SetCalculatedValue(undefined, ValueType.undefined);
@@ -1116,9 +1145,15 @@ export class Calculator extends Graph {
 
         // single, recycle
 
+        let applied: UnionValue = { ...value };
+        
+        if (applied.type === ValueType.object) {
+          applied = { type: ValueType.undefined, value: undefined };
+        }
+
         for (let row = 0; row < rows; row++) {
           for (let column = 0; column < columns; column++) {
-            cells.data[row + area.start.row][column + area.start.column].SetCalculatedValue(value.value, value.type);
+            cells.data[row + area.start.row][column + area.start.column].SetCalculatedValue(applied.value, applied.type);
           }
         }
         
@@ -1343,7 +1378,7 @@ export class Calculator extends Graph {
 
     const list = this.library.List();
 
-    const function_list = Object.keys(list).map((key) => {
+    const function_list: FunctionDescriptor[] = Object.keys(list).map((key) => {
       let name = list[key].canonical_name;
       if (!name) name = key.replace(/_/g, '.');
       return {
@@ -1352,6 +1387,7 @@ export class Calculator extends Graph {
         arguments: (list[key].arguments || []).map((argument) => {
           return { name: argument.name || '' };
         }),
+        type: 'function', // DescriptorType.Function,
       };
     });
 
@@ -1362,6 +1398,7 @@ export class Calculator extends Graph {
         arguments: (macro.argument_names || []).map(argument => {
           return { name: argument };
         }),
+        type: 'function', // DescriptorType.Function,
       });
     }
 
@@ -1402,9 +1439,10 @@ export class Calculator extends Graph {
   public RegisterFunction(map: FunctionMap): void {
 
     for (const name of Object.keys(map)) {
+
       const descriptor = map[name];
       const original_function = descriptor.fn;
-
+     
       // we don't bind to the actual context because that would allow
       // functions to change it, and potentially break subsequent functions
       // that rely on it. which is a pretty far-fetched scenario, but we might
@@ -1886,7 +1924,7 @@ export class Calculator extends Graph {
     const area = IsCellAddress(ref) ? new Area(ref) : new Area(ref.start, ref.end);
 
     if (named) {
-      const named_range = this.model.named_ranges.MatchSelection(area);
+      const named_range = this.model.named.MatchSelection(area);
       if (named_range) {
         return named_range;
       }
@@ -1938,7 +1976,7 @@ export class Calculator extends Graph {
   }
 
   public RemoveConnectedELement(element: ConnectedElementType) {
-    let internal = element.internal as { vertex: StateLeafVertex };
+    const internal = element.internal as { vertex: StateLeafVertex };
     if (internal?.vertex) {
       this.RemoveLeafVertex(internal.vertex);
       return true;
@@ -1959,7 +1997,7 @@ export class Calculator extends Graph {
     }
 
     if (element) {
-      let internal = element.internal as { vertex: StateLeafVertex };
+      const internal = element.internal as { vertex: StateLeafVertex };
       if (internal?.vertex) {
         this.RemoveLeafVertex(internal.vertex);
       }
@@ -2094,10 +2132,11 @@ export class Calculator extends Graph {
   }
 
   public RemoveAnnotation(annotation: Annotation): void {
-    const vertex = (annotation.temp.vertex as LeafVertex);
-    if (!vertex) { return; }
-    vertex.Reset();
-    this.RemoveLeafVertex(vertex);
+    const vertex_data = annotation.temp as { vertex?: LeafVertex };
+    if (vertex_data.vertex) {
+      vertex_data.vertex.Reset();
+      this.RemoveLeafVertex(vertex_data.vertex);
+    }
   }
 
   public UpdateAnnotations(list?: Annotation|Annotation[], context?: Sheet): void {
@@ -2126,12 +2165,15 @@ export class Calculator extends Graph {
 
     for (const entry of list) {
       if (entry.data.formula) {
-        if (!entry.temp.vertex) {
-          entry.temp.vertex = new StateLeafVertex();
+
+        const vertex_data = entry.temp as { vertex?: LeafVertex };
+
+        if (!vertex_data.vertex) {
+          vertex_data.vertex = new StateLeafVertex();
         }
-        const vertex = entry.temp.vertex as LeafVertex;
-        this.AddLeafVertex(vertex);
-        this.UpdateLeafVertex(vertex, entry.data.formula, context);
+
+        this.AddLeafVertex(vertex_data.vertex);
+        this.UpdateLeafVertex(vertex_data.vertex, entry.data.formula, context);
       }
     }
 
@@ -2162,9 +2204,9 @@ export class Calculator extends Graph {
       case 'identifier':
         {
           const named_range =
-            this.model.named_ranges.Get(expr.name.toUpperCase());
-          if (named_range) {
-            return new Area(named_range.start, named_range.end);
+            this.model.GetName(expr.name, context?.sheet_id || 0);
+          if (named_range && named_range.type === 'range') {
+            return new Area(named_range.area.start, named_range.area.end);
           }
         }
         break;
@@ -2174,19 +2216,19 @@ export class Calculator extends Graph {
 
   }
 
-  protected NamedRangeToAddressUnit(unit: UnitIdentifier): UnitAddress|UnitRange|undefined {
+  protected NamedRangeToAddressUnit(unit: UnitIdentifier, context: ICellAddress): UnitAddress|UnitRange|undefined {
 
     const normalized = unit.name.toUpperCase();
-    const named_range = this.model.named_ranges.Get(normalized);
-    if (named_range) {
-      if (named_range.count === 1) {
-        return this.ConstructAddressUnit(named_range.start, normalized, unit.id, unit.position);
+    const named_range = this.model.GetName(normalized, context.sheet_id || 0);
+    if (named_range && named_range.type === 'range') {
+      if (named_range.area.count === 1) {
+        return this.ConstructAddressUnit(named_range.area.start, normalized, unit.id, unit.position);
       }
       else {
         return {
           type: 'range',
-          start: this.ConstructAddressUnit(named_range.start, normalized, unit.id, unit.position),
-          end: this.ConstructAddressUnit(named_range.end, normalized, unit.id, unit.position),
+          start: this.ConstructAddressUnit(named_range.area.start, normalized, unit.id, unit.position),
+          end: this.ConstructAddressUnit(named_range.area.end, normalized, unit.id, unit.position),
           label: normalized,
           id: unit.id,
           position: unit.position,
@@ -2251,16 +2293,13 @@ export class Calculator extends Graph {
           // update to handle named expressions. just descend into
           // the expression as if it were inline.
           
-          const normalized = unit.name.toUpperCase();
+          const fetched = this.model.GetName(unit.name, context_address.sheet_id || 0);
 
-          if (this.model.named_expressions.has(normalized)) {
-            const expr = this.model.named_expressions.get(normalized);
-            if (expr) {
-              this.RebuildDependencies(expr, relative_sheet_id, relative_sheet_name, dependencies, context_address);
-            }
+          if (fetched?.type === 'expression') {
+            this.RebuildDependencies(fetched.expression, relative_sheet_id, relative_sheet_name, dependencies, context_address);
           }
           else {
-            const resolved = this.NamedRangeToAddressUnit(unit);
+            const resolved = this.NamedRangeToAddressUnit(unit, context_address);
             if (resolved) {
               if (resolved.type === 'address') {
                 dependencies.addresses[resolved.label] = resolved;
@@ -2506,96 +2545,6 @@ export class Calculator extends Graph {
 
   }
 
-  /* *
-   * we're passing model here to skip the test on each call
-   * 
-   * @param unit 
-   * @param model 
-   * /
-  protected ApplyMacroFunctionInternal(
-      unit: ExpressionUnit, 
-      model: DataModel, 
-      name_stack: Array<{[index: string]: ExpressionUnit}>,
-    ): ExpressionUnit { 
-
-      switch (unit.type) {
-
-        case 'identifier':
-          if (name_stack[0]) {
-            const value = name_stack[0][(unit.name || '').toUpperCase()];
-            if (value) {
-              return JSON.parse(JSON.stringify(value)) as ExpressionUnit;
-            }
-          }
-          break;
-
-        case 'binary':
-          unit.left = this.ApplyMacroFunctionInternal(unit.left, model, name_stack);
-          unit.right = this.ApplyMacroFunctionInternal(unit.right, model, name_stack);
-          break;
-  
-        case 'unary':
-          unit.operand = this.ApplyMacroFunctionInternal(unit.operand, model, name_stack);
-          break;
-  
-        case 'group':
-          unit.elements = unit.elements.map(element => this.ApplyMacroFunctionInternal(element, model, name_stack));
-          break;
-  
-        case 'call':
-          {
-            // do this first, so we can pass through directly
-            unit.args = unit.args.map(arg => this.ApplyMacroFunctionInternal(arg, model, name_stack));
-
-            const func = this.library.Get(unit.name);
-            if (!func) { 
-              const macro = model.macro_functions[unit.name.toUpperCase()];
-              if (macro && macro.expression) {
-
-                // clone
-                const expression = JSON.parse(JSON.stringify(macro.expression));
-
-                const bound_names: {[index: string]: ExpressionUnit} = {};
-
-                if (macro.argument_names) {
-                  for (let i = 0; i < macro.argument_names.length; i++) {
-                    const name = macro.argument_names[i].toUpperCase();
-          
-                    // temp just pass in
-                    bound_names[name] = unit.args[i] ? unit.args[i] : {type: 'missing'} as UnitMissing;
-                  }
-                }
-
-                // replace arguments
-                name_stack.unshift(bound_names);
-                const replacement = this.ApplyMacroFunctionInternal(expression, model, name_stack);                
-                name_stack.shift();
-                return replacement;
-
-              }
-            }
-          }
-
-          break;
-
-      }
-
-      return unit;
-
-  }
-
-  protected ApplyMacroFunctions(expression: ExpressionUnit): ExpressionUnit|undefined {
-
-    if (!this.model) { return; }
-
-    const count = Object.keys(this.model.macro_functions).length;
-    if (!count) { return; }
-
-    return this.ApplyMacroFunctionInternal(expression, this.model, []);
-
-  }
-  */
-
   /** 
    * 
    */

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

@@ -21,7 +21,6 @@
 
 import type { GraphCallbacks } from './spreadsheet_vertex_base';
 import { SpreadsheetVertex } from './spreadsheet_vertex';
-import type { Vertex} from './vertex';
 import { Color } from './vertex';
 
 /**
@@ -97,7 +96,7 @@ export class CalculationLeafVertex extends SpreadsheetVertex {
 
   }
 
-  public AddDependent(edge: Vertex): void {
+  public AddDependent(): void {
     throw(new Error('leaf vertex cannot have dependents'));
   }
 

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

@@ -27,7 +27,7 @@ import type { SpreadsheetVertexBase, CalculationResult, GraphCallbacks } from '.
 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 type { DataModel } from 'treb-data-model';
 import { CalculationLeafVertex } from './calculation_leaf_vertex';
 
 export type LeafVertex = StateLeafVertex|CalculationLeafVertex;
@@ -696,7 +696,7 @@ export abstract class Graph implements GraphCallbacks {
   }
 
   /** adds an edge from u -> v */
-  public AddEdge(u: ICellAddress, v: ICellAddress, tag?: string): void {
+  public AddEdge(u: ICellAddress, v: ICellAddress, /* tag?: string */ ): void {
 
     const v_u = this.GetVertex(u, true);
     const v_v = this.GetVertex(v, true);
@@ -732,7 +732,7 @@ export abstract class Graph implements GraphCallbacks {
         ...u,
         row: v_u.reference.area.start.row,
         column: v_u.reference.area.start.column,
-      }, v, 'implicit');
+      }, v); // , 'implicit');
     }
 
     this.loop_check_required = true; // because new edges

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

@@ -21,7 +21,7 @@
 
 import type { GraphCallbacks } from './spreadsheet_vertex_base';
 import { SpreadsheetVertexBase } from './spreadsheet_vertex_base';
-import type { Cell, ICellAddress, UnionValue } from 'treb-base-types';
+import type { Cell, CellValue, ICellAddress, UnionValue } from 'treb-base-types';
 import { Box, ValueType } from 'treb-base-types';
 import type { ExpressionUnit } from 'treb-parser';
 import { Color } from './vertex';
@@ -237,7 +237,7 @@ export class SpreadsheetVertex extends SpreadsheetVertexBase {
         // whitelist types. or blacklist types. or something.
 
         {
-          this.reference.SetCalculatedValue(single.value as any, single.type);
+          this.reference.SetCalculatedValue(single.value as CellValue, single.type);
         }
 
         /*

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

@@ -19,9 +19,7 @@
  * 
  */
 
-import type { GraphCallbacks } from './spreadsheet_vertex_base';
 import { SpreadsheetVertex } from './spreadsheet_vertex';
-import type { Vertex} from './vertex';
 import { Color } from './vertex';
 
 /**
@@ -93,7 +91,7 @@ export class StateLeafVertex extends SpreadsheetVertex {
   }
 
   /** overrides calculate function */
-  public Calculate(graph: GraphCallbacks): void {
+  public Calculate(): void {
 
     // if we are not dirty, nothing to do
     if (!this.dirty) return;
@@ -112,7 +110,7 @@ export class StateLeafVertex extends SpreadsheetVertex {
     // we are not allowed to have edges out, so nothing to do
   }
 
-  public AddDependent(edge: Vertex): void {
+  public AddDependent(): void {
     throw(new Error('leaf vertex cannot have dependents'));
   }