@trebco/treb 29.5.4 → 29.7.5

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

@@ -58,6 +58,7 @@ type ExpressionWithCachedFunction<T extends ExpressionUnit> = T extends { type:
 export type ExtendedExpressionUnit = ExpressionWithCachedFunction<ExpressionUnit>;
 
 // FIXME: move
+// FIXME: this is sloppy
 export const UnionIsExpressionUnit = (test: UnionValue /*UnionOrArray*/): test is { type: ValueType.object, value: ExpressionUnit } => {
   return !Array.isArray(test) 
       && test.type === ValueType.object
@@ -65,15 +66,9 @@ export const UnionIsExpressionUnit = (test: UnionValue /*UnionOrArray*/): test i
 };
 
 // FIXME: move
+// FIXME: this is sloppy
 export const UnionIsMetadata = (test: UnionValue /*UnionOrArray*/): test is { type: ValueType.object, value: ReferenceMetadata } => {
-
   return test.type === ValueType.object && test.key === 'metadata';
-
-  /*
-  return !Array.isArray(test) 
-      && test.type === ValueType.object
-      && ((test.value as ReferenceMetadata).type === 'metadata');
-    */
 };
 
 // FIXME: move
@@ -89,7 +84,6 @@ export interface ReferenceMetadata {
 
 export interface CalculationContext {
   address: ICellAddress;
-  // model?: DataModel;
   volatile: boolean;
 }
 
@@ -100,10 +94,6 @@ export class ExpressionCalculator {
     volatile: false,
   };
 
-  //
-  // protected data_model!: DataModel; // can we set in ctor? I think this is a legacy hack
-
-
   // --- public API -----------------------------------------------------------
 
   constructor(
@@ -111,18 +101,6 @@ export class ExpressionCalculator {
     protected readonly library: FunctionLibrary,
     protected readonly parser: Parser) {}
 
-  /*
-  public SetModel(model: DataModel): void {
-
-    // is this kept around for some side-effects or something? does 
-    // the model ever change?
-
-    this.data_model = model;
-    this.context.model = model;
-    
-  }
-  */
-
   /**
    * there's a case where we are calling this from within a function
    * (which is weird, but hey) and to do that we need to preserve flags.
@@ -131,10 +109,8 @@ export class ExpressionCalculator {
       value: UnionValue /*UnionOrArray*/, volatile: boolean }{
 
     if (!preserve_flags) {
-
       this.context.address = addr;
       this.context.volatile = false;
-
     }
 
     return {
@@ -154,8 +130,6 @@ export class ExpressionCalculator {
     if (!expr.sheet_id) {
       if (expr.sheet) {
         expr.sheet_id = this.data_model.sheets.ID(expr.sheet) || 0;
-
-        // expr.sheet_id = this.sheet_name_map[expr.sheet.toLowerCase()];
       }
       else {
         return () => ReferenceError();
@@ -178,7 +152,6 @@ export class ExpressionCalculator {
 
     if (!cell) {
       return () => { 
-        // return { type: ValueType.undefined, value: undefined } 
         return { type: ValueType.number, value: 0 };
       };
     }
@@ -199,9 +172,7 @@ export class ExpressionCalculator {
       // throw new Error('missing sheet id in CellFunction4');
     }
 
-    //const cells = this.cells_map[start.sheet_id];
     const cells = this.data_model.sheets.Find(start.sheet_id)?.cells;
-
     return cells?.GetRange4(start, end, true) || ReferenceError();
 
   }
@@ -241,7 +212,6 @@ export class ExpressionCalculator {
 
     case 'identifier':
       {
-        // const named_range = this.named_range_map[arg.name.toUpperCase()];
         const named_range = this.data_model.GetName(arg.name, this.context.address.sheet_id || 0);
         if (named_range?.type === 'range') {
           if (named_range.area.count === 1) {
@@ -290,29 +260,18 @@ export class ExpressionCalculator {
 
       // don't we have a map? [...] only for names?
 
-      let sheet: Sheet|undefined; // = this.data_model.active_sheet;
-      if (address.sheet_id) { // && address.sheet_id !== sheet.id) {
+      let sheet: Sheet|undefined;
+      if (address.sheet_id) {
         sheet = this.data_model.sheets.Find(address.sheet_id);
-
-        /*
-        for (const test of this.data_model.sheets) {
-          if (test.id === address.sheet_id) {
-            sheet = test;
-            break;
-          }
-        }
-        */
       }
 
       if (!sheet) {
-        // throw new Error('missing sheet [ac8]');
         console.error('missing sheet [ac8]');
         return ReferenceError();
       }
 
       const cell_data = sheet.CellData(address);
-      const value = // (cell_data.type === ValueType.formula) ? cell_data.calculated : cell_data.value;
-        cell_data.calculated_type ? cell_data.calculated : cell_data.value;
+      const value = cell_data.calculated_type ? cell_data.calculated : cell_data.value;
 
       const metadata: ReferenceMetadata = {
         type: 'metadata',
@@ -345,22 +304,12 @@ export class ExpressionCalculator {
         return ReferenceError();
       }
 
-      let sheet: Sheet|undefined; // = this.data_model.active_sheet;
-      if (range.start.sheet_id) { // && range.start.sheet_id !== sheet.id) {
+      let sheet: Sheet|undefined;
+      if (range.start.sheet_id) {
         sheet = this.data_model.sheets.Find(range.start.sheet_id);
-        /*
-        for (const test of this.data_model.sheets) {
-          if (test.id === range.start.sheet_id) {
-            sheet = test;
-            break;
-          }
-        }
-        */
       }
 
       if (!sheet) {
-        // console.info({range, context: JSON.stringify(this.context.address)});
-        // console.info({arg});
         throw new Error('missing sheet [ac9]');
       }
 
@@ -372,8 +321,7 @@ export class ExpressionCalculator {
           const cell_data = sheet.CellData({row, column});
           address = {...range.start, row, column};
 
-          const value = // (cell_data.type === ValueType.formula) ? cell_data.calculated : cell_data.value;
-            cell_data.calculated_type ? cell_data.calculated : cell_data.value;
+          const value = cell_data.calculated_type ? cell_data.calculated : cell_data.value;
 
           const metadata = {
             type: 'metadata',
@@ -464,35 +412,7 @@ export class ExpressionCalculator {
   }
 
   /** 
-   * excutes a function call 
-   *
-   * the return type of functions has never been locked down, and as a result
-   * there are a couple of things we need to handle. 
-   * 
-   * return type can be any value, essentially, or array, error object, or 
-   * (in the case of some of the reference/lookup functions) an address or 
-   * range expression. array must be 2d, I think? not sure that that is true.
-   * 
-   * this wrapper function returns a function which returns one of those
-   * things, i.e. it returns (expr) => return type
-   * 
-   * it will only return address/range if the parameter flag is set, so we
-   * could in theory lock it down a bit with overloads.
-   * 
-   * ---
-   * 
-   * UPDATE: that's no longer the case. we require that functions return 
-   * a UnionValue type (union), which can itself contain an array.
-   * 
-   * ---
-   * 
-   * FIXME: there is far too much duplication between this and the MC version
-   * (in simulation-expression-calculator). we need to find a way to consolidate
-   * these.
-   * 
-   * I think the problem is that we don't want a lot of switches, but the cost
-   * is an almost complete duplicate of this function in the subclass.
-   * 
+   * excute a function call 
    */
   protected CallExpression(outer: UnitCall, return_reference = false): (expr: UnitCall) => UnionValue /*UnionOrArray*/ {
 
@@ -513,45 +433,18 @@ export class ExpressionCalculator {
 
     return (expr: UnitCall) => {
 
-      // yeah so this is clear. just checking volatile.
-
-      // FIXME: should this be set later, at the same time as the
-      // calculation index? I think it should, since we may recurse.
-
-      // BEFORE YOU DO THAT, track down all references that read this field
-
-      // from what I can tell, the only place this is read is after the
-      // external (outer) Calculate() call. so we should move this assignment,
-      // and we should also be able to get it to fail:
-      //
-      // RandBetween() should be volatile, but if we have a nonvolatile function
-      // as an argument that should unset it, and remove the volatile flag.
-      // Check?
-
-      // actually this works, because it only sets the flag (does not unset).
-      // volatile applies to the _cell_, not just the function -- so as long
-      // as the outer function sets the flag, it's not material if an inner
-      // function is nonvolatile. similarly an inner volatile function will
-      // make the outer function volatile.
-
-      // this does mean that the nonvolatile function will be treated differently
-      // if it's an argument to a volatile function, but I think that's reasonable
-      // behavior; also it's symmetric with the opposite case (inner volatile.)
-
-      // so leave this as-is, or you can move it -- should be immaterial
-
+      // set context volatile if this function is volatile. it will bubble
+      // through nested function calls, so the entire cell will be volatile 
+      // if there's a volatile function in there somewhere
+      
       this.context.volatile = this.context.volatile || (!!func.volatile);
 
-      // NOTE: the argument logic is (possibly) calculating unecessary operations,
-      // if there's a conditional (like an IF function). although that is the
-      // exception rather than the rule...
-
-      // ok we can handle IF functions, at the expense of some tests... 
-      // is it worth it? 
-
+      // we recurse calculation, but in the specific case of IF functions
+      // we can short-circuit and skip the unused code path. doesn't apply
+      // anywhere else atm
+      
       const if_function = outer.name.toLowerCase() === 'if';
       let skip_argument_index = -1;
-
       let argument_error: UnionValue|undefined;
 
       const argument_descriptors = func.arguments || []; // map
@@ -593,16 +486,12 @@ export class ExpressionCalculator {
           } : this.parser.Render(arg).replace(/\$/g, '');
         }
         else if (descriptor.metadata) {
-
           return this.GetMetadata(arg, () => { return {}}); // type is UnionOrArray
-
         }
         else {
 
           const result = this.CalculateExpression(arg as ExtendedExpressionUnit);
 
-          // if (!Array.isArray(result) && result.type === ValueType.error) {
-
           if (result.type === ValueType.error) { // array check is implicit since array is a type
             if (descriptor.allow_error) {
               return result; // always boxed
@@ -613,11 +502,9 @@ export class ExpressionCalculator {
 
           // can't shortcut if you have an array (or we need to test all the values)
 
-          //if (if_function && arg_index === 0 && !Array.isArray(result)) {
-          if (if_function && arg_index === 0 && result.type !== ValueType.array){ // !Array.isArray(result)) {
-              let result_truthy = false; 
+          if (if_function && arg_index === 0 && result.type !== ValueType.array){
 
-            // if (Array.isArray(result)) { result_truthy = true; }
+            let result_truthy = false; 
 
             if (result.type === ValueType.string) {
               const lowercase = (result.value as string).toLowerCase().trim();
@@ -626,6 +513,7 @@ export class ExpressionCalculator {
             else {
               result_truthy = !!result.value;
             }
+
             skip_argument_index = result_truthy ? 2 : 1;
           }
 
@@ -633,11 +521,6 @@ export class ExpressionCalculator {
             return result;
           }
 
-          /*
-          if (Array.isArray(result)) {
-            return result.map(row => row.map(value => value.value));
-          }
-          */
           if (result.type === ValueType.array) {
             return (result as ArrayUnion).value.map(row => row.map(value => value.value));            
           }
@@ -653,12 +536,6 @@ export class ExpressionCalculator {
         return argument_error;
       }
 
-      // I thought we were passing the model as this (...) ? actually
-      // now we bind functions that need this, so maybe we should pass
-      // null here.
-
-      // return func.fn.apply(null, mapped_args);
-      
       if (func.return_type === ReturnType.reference) {
 
         const result = func.fn.apply(null, mapped_args);
@@ -757,11 +634,6 @@ export class ExpressionCalculator {
               value: (operand as ArrayUnion).value.map(column => column.map(value => func(zero, value))),
             };
           }
-          /*
-          if (Array.isArray(operand)) {
-            return operand.map(column => column.map(value => func(zero, value)));
-          }
-          */
           return func(zero, operand);
         };
 
@@ -929,31 +801,17 @@ export class ExpressionCalculator {
 
     return () => {
 
-      /*
-      if (this.bound_name_stack[0]) {
-        const expr = this.bound_name_stack[0][upper_case];
-        if (expr) {
-          console.info("BOUND", upper_case, expr);
-          return this.CalculateExpression(expr as ExtendedExpressionUnit);
-        }
-      }
-      */
-
-      // const named_range = this.named_range_map[upper_case];
-      const named_range = this.data_model.GetName(upper_case, this.context.address.sheet_id || 0);
-
-      if (named_range?.type === 'range') {
-        if (named_range.area.count === 1) {
-          return this.CellFunction4(named_range.area.start, named_range.area.start);
-        }
-        else {
-          return this.CellFunction4(named_range.area.start, named_range.area.end);
-        }
-      }
-
-      const named2 = this.data_model.GetName(identifier, this.context.address.sheet_id || 0);
-      if (named2 && named2.type === 'expression') {
-        return this.CalculateExpression(named2.expression as ExtendedExpressionUnit);
+      const named = this.data_model.GetName(upper_case, this.context.address.sheet_id || 0);
+      
+      switch (named?.type) {
+        case 'range':
+          if (named.area.count === 1) {
+            return this.CellFunction4(named.area.start, named.area.start);
+          }
+          return this.CellFunction4(named.area.start, named.area.end);
+          
+        case 'expression':
+          return this.CalculateExpression(named.expression as ExtendedExpressionUnit);
       }
 
       // console.info( '** identifier', {identifier, expr, context: this.context});

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

@@ -40,14 +40,6 @@ export interface FunctionError {
   error: ErrorType;
 }
 
-// export const ArgumentError: FunctionError = { error: ErrorType.Argument };
-// export const ReferenceError: FunctionError = { error: ErrorType.Reference };
-//export const ExpressionError: FunctionError = { error: ErrorType.Expression };
-// export const NameError: FunctionError = { error: ErrorType.Name };
-// export const ValueError: FunctionError = { error: ErrorType.Value };
-// export const DataError: FunctionError = { error: ErrorType.Data };
-// export const DivideByZeroError: FunctionError = { error: ErrorType.Div0 };
-// export const UnknownError: FunctionError = { error: ErrorType.Unknown };
 export const NotImplError: FunctionError = { error: ErrorType.NotImpl };
 
 export const NAError = (): UnionValue => {
@@ -87,18 +79,21 @@ export const UnknownError = (): UnionValue => {
 };
 
 
-/** type guard function */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const IsError = (test: any): test is FunctionError => {
-  return test && typeof test.error && (
-    test.error === ErrorType.Argument ||
-    test.error === ErrorType.Reference ||
-    test.error === ErrorType.Name ||
-    test.error === ErrorType.Expression ||
-    test.error === ErrorType.Data ||
-    test.error === ErrorType.Unknown ||
-    test.error === ErrorType.NotImpl ||
-    test.error === ErrorType.Value ||
-    test.error === ErrorType.Div0
+/** 
+ * type guard function 
+ *
+ * ...this is maybe too precise?  
+ */
+export const IsError = (test: unknown): test is FunctionError => {
+  return !!test && typeof test === 'object' && !!(test as FunctionError).error && (
+    (test as FunctionError).error === ErrorType.Argument ||
+    (test as FunctionError).error === ErrorType.Reference ||
+    (test as FunctionError).error === ErrorType.Name ||
+    (test as FunctionError).error === ErrorType.Expression ||
+    (test as FunctionError).error === ErrorType.Data ||
+    (test as FunctionError).error === ErrorType.Unknown ||
+    (test as FunctionError).error === ErrorType.NotImpl ||
+    (test as FunctionError).error === ErrorType.Value ||
+    (test as FunctionError).error === ErrorType.Div0
   );
 };

package/treb-calculator/src/functions/matrix-functions.ts

@@ -147,7 +147,7 @@ export const MatrixFunctionLibrary: FunctionMap = {
   },
 
   MMult: {
-    description: 'Returns the dot product of A and B',
+    description: 'Returns the dot product A ⋅ B',
     arguments: [
       { name: 'A', boxed: true }, 
       { name: 'B', boxed: true }, 

package/treb-charts/src/util.ts

@@ -23,16 +23,6 @@
 import type { RangeScale} from 'treb-utils';
 import { Scale } from 'treb-utils';
 
-/* * calculated human-friendly scale for rendering axes * /
-export interface RangeScale {
-  scale: number;
-  step: number;
-  count: number;
-  min: number;
-  max: number;
-}
-*/
-
 export class Util {
 
   /**
@@ -63,32 +53,9 @@ export class Util {
     return range * (value - scale.min) / (scale.max - scale.min);
   }
 
-  /* *
-   * flatten. we support holes in data, which means undefined values
-   * in arrays, but don't push an empty value at the top level (if
-   * that makes sense).
-   *
-   * @deprecated
-   * /
-  public static Flatten(args: any) {
-    let flat: any[] = [];
-    if (Array.isArray(args)) {
-      for (const element of args) {
-        if (Array.isArray(element)) {
-          flat = flat.concat(this.Flatten(element));
-        }
-        else {
-          flat.push(element);
-        }
-      }
-    }
-    else if (typeof args !== 'undefined') {
-      flat.push(args);
-    }
-    return flat;
-  }
-  */
-
+  /**
+   * can we replace this with Array.flatMap?
+   */
   public static Flatten<T>(args?: T|T[]|T[][]) {
     let flat: T[] = [];
     if (Array.isArray(args)) {

package/treb-data-model/src/data_model.ts

@@ -21,34 +21,13 @@
 
 import type { Sheet } from './sheet';
 import { SheetCollection } from './sheet_collection';
+import { type UnitAddress, type UnitStructuredReference, type UnitRange, Parser, QuotedSheetNameRegex, DecimalMarkType, ArgumentSeparatorType } from 'treb-parser';
 import type { IArea, ICellAddress, Table, CellStyle } from 'treb-base-types';
-import type { SerializedSheet } from './sheet_types';
-import { type ExpressionUnit, type UnitAddress, type UnitStructuredReference, type UnitRange, Parser, QuotedSheetNameRegex, DecimalMarkType, ArgumentSeparatorType } from 'treb-parser';
 import { Area, IsCellAddress, Style } from 'treb-base-types';
 import type { SerializedNamed } from './named';
 import { NamedRangeManager } from './named';
+import type { ConnectedElementType, MacroFunction } from './types';
 
-export interface ConnectedElementType {
-  formula: string;
-  update?: (instance: ConnectedElementType) => void;
-  internal?: unknown; // opaque type to prevent circular dependencies
-}
-
-export interface SerializedMacroFunction {
-  name: string;
-  function_def: string;
-  argument_names?: string[];
-  description?: string;
-}
-
-/**
- * we define this as extending the serialized version, rather
- * than taking out the parameter, so we can make that def public
- * in the API types.
- */
-export interface MacroFunction extends SerializedMacroFunction {
-  expression?: ExpressionUnit;
-}
 
 /**
  * 
@@ -546,43 +525,3 @@ export class DataModel {
 
 }
 
-/**
- * @internal
- */
-export interface ViewModel {
-  active_sheet: Sheet;
-  view_index: number;
-}
-
-/** 
- * this type is no longer in use, but we retain it to parse old documents
- * that use it. 
- * 
- * @deprecated
- */
-export interface SerializedNamedExpression {
-  name: string;
-  expression: string;
-}
-
-export interface SerializedModel {
-  sheet_data: SerializedSheet[];
-  active_sheet: number;
-
-  /** @deprecated */
-  named_ranges?: Record<string, IArea>;
-
-  /** @deprecated */
-  named_expressions?: SerializedNamedExpression[];
-
-  /** 
-   * new type for consolidated named ranges & expressions. the old
-   * types are retained for backwards compatibility on import but we won't 
-   * export them anymore.
-   */
-  named?: SerializedNamed[];
-
-  macro_functions?: MacroFunction[];
-  tables?: Table[];
-  decimal_mark?: ','|'.';
-}

package/treb-data-model/src/index.ts

@@ -20,16 +20,6 @@
  */
 
 export { DataModel } from './data_model';
-
-export type { 
-  MacroFunction, 
-  ConnectedElementType,
-  SerializedNamedExpression, 
-  SerializedModel, 
-  ViewModel, 
-  SerializedMacroFunction,
-} from './data_model';
-
 export type { SerializedNamed } from './named';
 
 export { Sheet } from './sheet';
@@ -43,3 +33,5 @@ export type { ViewData as AnnotationViewData } from './annotation';
 export type { AnnotationData, AnnotationType } from './annotation';
 
 export * from './data-validation';
+export * from './types';
+

package/treb-data-model/src/sheet.ts

@@ -2225,8 +2225,14 @@ export class Sheet {
       return this.CompositeStyleForCell(area, true, false, apply_theme);
     }
 
+    // the contract says this should return an array, not a single value.
+    // 
+    // I can fix it, but will anyone break? (...) check the indent buttons
+    // (update: looks OK)
+    // 
+
     if (area.start.row === area.end.row && area.start.column === area.end.column) {
-      return this.CompositeStyleForCell(area.start, true, false, apply_theme);
+      return [[this.CompositeStyleForCell(area.start, true, false, apply_theme)]];
     }
 
     const result: CellStyle[][] = [];
@@ -2234,8 +2240,6 @@ export class Sheet {
     for (let r = area.start.row; r <= area.end.row; r++) {
       const row: CellStyle[] = [];
       for (let c = area.start.column; c <= area.end.column; c++) {
-        // const cell = this.CellData({row: r, column: c});
-        // row.push(cell.style || {});
         row.push(this.CompositeStyleForCell({row: r, column: c}, true, false, apply_theme));
       }
       result.push(row);