@trebco/treb 29.3.4 → 29.4.1

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v29.3. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v29.4. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map
@@ -743,13 +743,13 @@ export declare class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     /**
      * set or clear cell valiation.
      *
-     * @param address - target cell
+     * @param target - target cell/area
      * @param validation - a spreadsheet range, list of data, or undefined. pass
      * undefined to remove existing cell validation.
      * @param error - setting an invalid value in the target cell is an error (and
      * is blocked). defaults to false.
      */
-    SetValidation(address: AddressReference, validation?: RangeReference | CellValue[], error?: boolean): void;
+    SetValidation(target: RangeReference, validation?: RangeReference | CellValue[], error?: boolean): void;
 
     /**
      * Delete a macro function.
@@ -1727,7 +1727,6 @@ export interface BaseCellData {
     table?: Table;
     area?: IArea;
     merge_area?: IArea;
-    validation?: DataValidation;
     calculated_type?: SerializedValueType;
     note?: string;
     hyperlink?: string;
@@ -1817,27 +1816,6 @@ export interface Table {
      */
     sort?: TableSortOptions;
 }
-export type DataValidation = DataValidationList | DataValidationRange | DataValidationNumber | DataValidationDate | DataValidationBoolean;
-export interface DataValidationBase {
-    error?: boolean;
-}
-export interface DataValidationRange extends DataValidationBase {
-    type: 'range';
-    area: IArea;
-}
-export interface DataValidationList extends DataValidationBase {
-    type: 'list';
-    list: CellValue[];
-}
-export interface DataValidationDate extends DataValidationBase {
-    type: 'date';
-}
-export interface DataValidationNumber extends DataValidationBase {
-    type: 'number';
-}
-export interface DataValidationBoolean extends DataValidationBase {
-    type: 'boolean';
-}
 
 /**
  * string types for import/export

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trebco/treb",
-  "version": "29.3.4",
+  "version": "29.4.1",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {

package/treb-base-types/src/area.ts

@@ -584,6 +584,13 @@ export class Area implements IArea {
       && area.end_.column === this.end_.column;
   }
 
+  public Equals2(area: IArea): boolean {
+    return area.start.row === this.start_.row
+      && area.start.column === this.start_.column
+      && area.end.row === this.end_.row
+      && area.end.column === this.end_.column;
+  }
+
   public Clone(): Area {
     return new Area(this.start, this.end); // ensure copies
   }

package/treb-base-types/src/cell.ts

@@ -21,7 +21,7 @@
 
 // import { Parser } from 'treb-parser';
 
-import type { Area, IArea } from './area';
+import type { Area } from './area';
 import type { CellStyle } from './style';
 import type { TextPart } from './text_part';
 import type { Complex } from './value-type';
@@ -117,50 +117,6 @@ export type ClickFunction = (options: ClickFunctionOptions) => ClickFunctionResu
  *  - raw per-cell style information. this is in a separate array (object).
  */
 
-/**
- * validation TODO: date, number, boolean, &c
- */
-export enum ValidationType {
-  List = 'list',
-  Date = 'date',
-  Range = 'range',
-  Number = 'number',
-  Boolean = 'boolean',
-}
-
-export interface DataValidationBase {
-  error?: boolean;
-}
-
-export interface DataValidationRange extends DataValidationBase {
-  type: 'range'; // ValidationType.Range;
-  area: IArea;
-}
-
-export interface DataValidationList extends DataValidationBase {
-  type: 'list'; // ValidationType.List;
-  list: CellValue[];
-}
-
-export interface DataValidationDate extends DataValidationBase {
-  type: 'date'; // ValidationType.Date;
-}
-
-export interface DataValidationNumber extends DataValidationBase {
-  type: 'number'; // ValidationType.Number;
-}
-
-export interface DataValidationBoolean extends DataValidationBase {
-  type: 'boolean'; // ValidationType.Boolean;
-}
-
-export type DataValidation 
-  = DataValidationList
-  | DataValidationRange
-  | DataValidationNumber
-  | DataValidationDate
-  | DataValidationBoolean;
-
 export class Cell {
 
   // --- static methods -------------------------------------------------------
@@ -342,7 +298,7 @@ export class Cell {
   /** not editable */
   // public locked?: boolean;
 
-  public validation?: DataValidation;
+  // public validation?: DataValidation;
 
   // --- class methods --------------------------------------------------------
 

package/treb-base-types/src/cells.ts

@@ -26,7 +26,9 @@
 
 import type { IArea, ICellAddress} from './area';
 import { Area, IsCellAddress } from './area';
-import type { DataValidation } from './cell';
+
+// import type { DataValidation } from './cell';
+
 import { Cell } from './cell';
 import type { Table } from './table';
 import { type SerializedValueType, ValueType, GetValueType, ValueTypeList } from './value-type';
@@ -79,7 +81,7 @@ export interface BaseCellData {
   table?: Table;
   area?: IArea;
   merge_area?: IArea;
-  validation?: DataValidation;
+  // validation?: DataValidation;
   calculated_type?: SerializedValueType; //  ValueType;
   note?: string;
   hyperlink?: string;
@@ -404,7 +406,7 @@ export class Cells {
 
 
 
-  /**
+  /* *
    * this method is used for importing legacy data validation types. in those
    * those we used a numeric enum. we're just dropping that altogether (c.f.
    * ValueType, which we're keeping) so we need to translate for backcompat. 
@@ -419,7 +421,8 @@ export class Cells {
    *   Boolean = 'boolean',
    * }
    * 
-   */
+   * OK, removed
+   * /
   public ImportDataValidation(value: DataValidation): DataValidation|undefined {
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -435,6 +438,7 @@ export class Cells {
 
     return value;
   }
+  */
 
   /**
    * UPDATE: adding optional style refs, for export
@@ -572,6 +576,7 @@ export class Cells {
         }
       }
 
+      /*
       if (obj.validation) {
 
         // the old type used a numeric enum. we just dropped that in favor
@@ -581,6 +586,7 @@ export class Cells {
         cell.validation = this.ImportDataValidation(obj.validation);
 
       }
+      */
 
     }
 
@@ -678,7 +684,7 @@ export class Cells {
               (merge_head || cell.type || (cell.calculated_type && options.expand_arrays) ||
                 (cell.calculated_type && options.calculated_value) ||
                 (cell.note) ||
-                (cell.validation) ||
+                // (cell.validation) ||
                 (options.decorated_cells && cell.style &&
                   ( cell.style.fill || cell.style.border_bottom ||
                     cell.style.border_top || cell.style.border_left || cell.style.border_right)))){
@@ -715,9 +721,9 @@ export class Cells {
             if (cell.merge_area) {
               obj.merge_area = cell.merge_area.toJSON();
             }
-            if (cell.validation) {
-              obj.validation = cell.validation; // safe? 
-            }
+            // if (cell.validation) {
+            //   obj.validation = cell.validation; // safe? 
+            // }
 
             if (options.cell_style_refs &&
                 options.cell_style_refs[column] &&

package/treb-base-types/src/import.ts

@@ -23,9 +23,8 @@ import type { CellStyle } from './style';
 import type { SerializedValueType } from './value-type';
 import type { IArea } from './area';
 import type { AnnotationLayout } from './layout';
-import type { DataValidation } from './cell';
 import type { Table } from './table';
-import type { AnnotationType, ConditionalFormat } from 'treb-data-model';
+import type { DataValidation, AnnotationType, ConditionalFormat } from 'treb-data-model';
 
 export interface CellParseResult {
   row: number,
@@ -60,6 +59,7 @@ export interface ImportedSheetData {
   row_heights: number[];
   styles: CellStyle[];
   conditional_formats: ConditionalFormat[];
+  data_validations?: DataValidation[];
 
   // optional, for backcompat
   sheet_style?: number;

package/treb-calculator/src/calculator.ts

@@ -184,7 +184,7 @@ export class Calculator extends Graph {
 
     super();
 
-    this.expression_calculator = new ExpressionCalculator(this.library, this.parser);
+    this.expression_calculator = new ExpressionCalculator(this.model, this.library, this.parser);
 
 
     // at the moment options are only used here; in the future
@@ -208,6 +208,9 @@ export class Calculator extends Graph {
 
     }
 
+    // FIXME: why is this called here, if model now owns it?
+    // TODO: move to model
+
     this.UpdateLocale(); // for parser
 
     // base functions
@@ -1391,6 +1394,11 @@ export class Calculator extends Graph {
       };
     });
 
+    // FIXME: this doesn't need to be here, if it's owned by model.
+    // we should have model responsible for retrieving these names
+    // (along with named ranges/expressions). also, should macro 
+    // functions support scoping?
+
     for (const macro of this.model.macro_functions.values()) {
       function_list.push({
         name: macro.name,
@@ -1448,8 +1456,7 @@ export class Calculator extends Graph {
       // that rely on it. which is a pretty far-fetched scenario, but we might
       // as well protect against it.
 
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      descriptor.fn = (...args: any[]) => {
+      descriptor.fn = (...args: unknown[]) => {
         return original_function.apply({
           address: { ...this.expression_calculator.context.address},
         }, args);
@@ -1460,22 +1467,23 @@ export class Calculator extends Graph {
 
   }
 
-  /**
+  /* *
    * wrap the attachdata function so we can update the expression calculator
    * at the same time (we should unwind this a little bit, it's an artifact
    * of graph being a separate class)
-   */
+   * /
   public AttachModel(): void {
     // this.RebuildMap();
-    this.expression_calculator.SetModel(this.model);
+    // this.expression_calculator.SetModel(this.model);
   }
+  */
 
   /**
    * wrapper method for calculation
    */
   public Calculate(subset?: Area): void {
 
-    this.AttachModel();
+    // this.AttachModel();
 
     // this gets checked later, now... it would be better if we could
     // check it here are skip the later check, but that field is optional
@@ -1539,7 +1547,7 @@ export class Calculator extends Graph {
   public Reset(): void {
 
     this.FlushTree();
-    this.AttachModel();
+    // this.AttachModel();
 
     this.full_rebuild_required = true;
   }
@@ -1572,7 +1580,10 @@ export class Calculator extends Graph {
     return map;
   }
 
+  /** overload */
   public Evaluate(expression: string, active_sheet?: Sheet, options?: EvaluateOptions, raw_result?: false): CellValue|CellValue[][];
+
+  /** overload */
   public Evaluate(expression: string, active_sheet?: Sheet, options?: EvaluateOptions, raw_result?: true): UnionValue;
 
   /** moved from embedded sheet */
@@ -1687,8 +1698,6 @@ export class Calculator extends Graph {
 
     this.full_rebuild_required = false; // unset
 
-    this.AttachModel();
-
     this.RebuildGraph();
 
     // add leaf vertices for annotations
@@ -1955,7 +1964,7 @@ export class Calculator extends Graph {
   }
 
   /**
-   * 
+   * FIXME: just add a quote option to the model method and we can drop this function
    */
   public ResolveSheetName(id: number, quote = false): string | undefined {
     const sheet = this.model.sheets.Find(id);
@@ -2792,10 +2801,11 @@ export class Calculator extends Graph {
 
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  /*
   protected IsNativeOrTypedArray(val: unknown): boolean {
     return Array.isArray(val) || (val instanceof Float64Array) || (val instanceof Float32Array);
   }
+  */
 
   /**
    * check if a cell is volatile. normally this falls out of the calculation,

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

@@ -639,6 +639,8 @@ export abstract class Graph implements GraphCallbacks {
 
     const map = this.vertices[u.start.sheet_id];
 
+    // console.info({u});
+
     // this might happen on create, we can let it go because the 
     // references will be added when the relevant sheet is added
 
@@ -680,10 +682,17 @@ export abstract class Graph implements GraphCallbacks {
     else {
       for (let row = u.start.row; row <= u.end.row; row++) {
         for (let column = u.start.column; column <= u.end.column; column++) {
-          const vertex = map[column][row];
-          if (vertex) {
-            array_vertex.DependsOn(vertex);
+          if (map[column]) {
+            const vertex = map[column][row];
+            if (vertex) {
+              array_vertex.DependsOn(vertex);
+            }
+          }
+          /*
+          else {
+            console.info("HERE", column, row);
           }
+          */
         }
       }
     }

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

@@ -27,7 +27,7 @@ import type { Cell, ICellAddress,
          UndefinedUnion,
          ComplexUnion, 
          DimensionedQuantityUnion} from 'treb-base-types';
-import { ValueType, GetValueType } from 'treb-base-types';
+import { ValueType, GetValueType, Area } from 'treb-base-types';
 import type { Parser, ExpressionUnit, UnitBinary, UnitIdentifier,
          UnitGroup, UnitUnary, UnitAddress, UnitRange, UnitCall, UnitDimensionedQuantity, UnitStructuredReference } from 'treb-parser';
 import type { DataModel, MacroFunction, Sheet } from 'treb-data-model';
@@ -36,8 +36,26 @@ import { ReturnType } from './descriptors';
 
 import * as Primitives from './primitives';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type ExtendedExpressionUnit = ExpressionUnit & { user_data: any }; // export for MC overload
+//////////
+
+/**
+ * dynamically adding a user data field to the expression so we can
+ * cache a function call, avoiding type switching and function lookups.
+ * 
+ * we use the generic type so we can cover the composite type as well
+ * before specifying
+ */
+type AttachCachedFunction<T> = (T & { fn: (arg0: T) => UnionValue });
+
+/**
+ * expression unit with cached function
+ */
+type ExpressionWithCachedFunction<T extends ExpressionUnit> = T extends { type: T['type'] } ? AttachCachedFunction<T> : never;
+
+/**
+ * @internal
+ */
+export type ExtendedExpressionUnit = ExpressionWithCachedFunction<ExpressionUnit>;
 
 // FIXME: move
 export const UnionIsExpressionUnit = (test: UnionValue /*UnionOrArray*/): test is { type: ValueType.object, value: ExpressionUnit } => {
@@ -61,16 +79,18 @@ export const UnionIsMetadata = (test: UnionValue /*UnionOrArray*/): test is { ty
 // FIXME: move
 export interface ReferenceMetadata {
   type: 'metadata';
+  
+  // what's the context in which I was using the unit address (parse expression?)
   address: UnitAddress; // ICellAddress;
+  
   value: CellValue;
   format?: string;
 }
 
 export interface CalculationContext {
   address: ICellAddress;
-  model?: DataModel;
+  // model?: DataModel;
   volatile: boolean;
-  call_index: number;
 }
 
 export class ExpressionCalculator {
@@ -78,57 +98,30 @@ export class ExpressionCalculator {
   public context: CalculationContext = {
     address: { row: -1, column: -1 },
     volatile: false,
-    call_index: 0,
   };
 
-  /**
-   * this refers to the number of function call within a single cell.
-   * so if you have a function like
-   *
-   * =A(B())
-   *
-   * then when calculating A call index should be set to 1; and when
-   * calculating B, call index is 2. and so on. 
-   */
-  protected call_index = 0;
-
-  // local reference
-  // protected cells: Cells = new Cells();
-  // protected cells_map: {[index: number]: Cells} = {};
-  // protected sheet_name_map: {[index: string]: number} = {};
-
-  // local reference
-  // protected named_range_map: {[index: string]: Area} = {};
-
-  // protected bound_name_stack: Array<Record<string, ExpressionUnit>> = [];
-
   //
-  protected data_model!: DataModel;
+  // protected data_model!: DataModel; // can we set in ctor? I think this is a legacy hack
 
 
   // --- public API -----------------------------------------------------------
 
   constructor(
+    protected readonly data_model: DataModel,
     protected readonly library: FunctionLibrary,
     protected readonly parser: Parser) {}
 
+  /*
   public SetModel(model: DataModel): void {
 
-    // this.cells_map = {};
-    // this.sheet_name_map = {};
-
-    /*
-    for (const sheet of model.sheets.list) {
-      // this.cells_map[sheet.id] = sheet.cells;
-      // this.sheet_name_map[sheet.name.toLowerCase()] = sheet.id;
-    }
-    */
+    // is this kept around for some side-effects or something? does 
+    // the model ever change?
 
     this.data_model = model;
-    // this.named_range_map = model.named_ranges.Map();
     this.context.model = model;
     
   }
+  */
 
   /**
    * there's a case where we are calling this from within a function
@@ -141,10 +134,6 @@ export class ExpressionCalculator {
 
       this.context.address = addr;
       this.context.volatile = false;
-      this.context.call_index = 0;
-
-      // reset for this cell
-      this.call_index = 0; // why not in model? A: timing (nested)
 
     }
 
@@ -218,8 +207,7 @@ export class ExpressionCalculator {
   }
 
   /** breaking this out to de-dupe */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  protected GetMetadata(arg: ExpressionUnit, map_result: (cell_data: Cell, address: ICellAddress) => any): UnionValue /*UnionOrArray*/ {
+  protected GetMetadata<T>(arg: ExpressionUnit, transform: (cell_data: Cell, address: ICellAddress) => T): UnionValue {
 
     // FIXME: we used to restrict this to non-cell functions, now
     // we are using it for the cell function (we used to use address,
@@ -328,10 +316,24 @@ export class ExpressionCalculator {
 
       const metadata: ReferenceMetadata = {
         type: 'metadata',
-        address: {...address},
+
+        // metadata is expecting a parse expression instead of an addresss.
+        // note we're not setting the label properly here, which could be 
+        // an issue? not sure who's calling it in this case
+
+        // UPDATE: "Cell" is calling it, so it needs a label
+
+        address: {
+          ...address,
+          position: 0,
+          id: 0,
+          type: 'address',
+          label: new Area(address).spreadsheet_label,
+        },
+
         value,
         format: cell_data.style ? cell_data.style.number_format : undefined,
-        ...map_result(cell_data, address),
+        ...transform(cell_data, address),
       };
 
       return { type: ValueType.object, value: metadata, key: 'metadata' };
@@ -378,7 +380,7 @@ export class ExpressionCalculator {
             address,
             value,
             format: cell_data.style ? cell_data.style.number_format : undefined,
-            ...map_result(cell_data, address),
+            ...transform(cell_data, address),
           };
 
           column_result.push({
@@ -511,11 +513,6 @@ export class ExpressionCalculator {
 
     return (expr: UnitCall) => {
 
-      // get an index we can use for this call (we may recurse when
-      // calculating arguments), then increment for the next call.
-
-      const call_index = this.call_index++;
-
       // yeah so this is clear. just checking volatile.
 
       // FIXME: should this be set later, at the same time as the
@@ -656,11 +653,6 @@ export class ExpressionCalculator {
         return argument_error;
       }
 
-      // if we have any nested calls, they may have updated the index so
-      // we use the captured value here.
-
-      this.context.call_index = call_index;
-
       // I thought we were passing the model as this (...) ? actually
       // now we bind functions that need this, so maybe we should pass
       // null here.
@@ -988,7 +980,7 @@ export class ExpressionCalculator {
     return (expr: UnitGroup) => this.CalculateExpression(expr.elements[0] as ExtendedExpressionUnit);
   }
 
-  protected CalculateExpression(expr: ExtendedExpressionUnit, return_reference = false): UnionValue /*UnionOrArray*/ {
+  protected CalculateExpression(expr: ExtendedExpressionUnit, return_reference = false): UnionValue {
 
     // user data is a generated function for the expression, at least
     // for the simple ones (atm). see BinaryExpression for more. the
@@ -996,8 +988,8 @@ export class ExpressionCalculator {
 
     // may be over-optimizing here.
 
-    if (expr.user_data) {
-      return expr.user_data(expr);
+    if ((expr as AttachCachedFunction<ExpressionUnit>).fn) {
+      return (expr as AttachCachedFunction<ExpressionUnit>).fn(expr);
     }
 
     switch (expr.type){
@@ -1005,52 +997,52 @@ export class ExpressionCalculator {
       {
         const macro = this.data_model.macro_functions.get(expr.name.toUpperCase());
         if (macro) {
-          return (expr.user_data = this.CallMacro(expr, macro))(expr);
+          return (expr.fn = this.CallMacro(expr, macro))(expr);
         }
-        return (expr.user_data = this.CallExpression(expr, return_reference))(expr);
+        return (expr.fn = this.CallExpression(expr, return_reference))(expr);
       }
 
     case 'address':
-      return (expr.user_data = this.CellFunction2(expr))(); // check
+      return (expr.fn = this.CellFunction2(expr))(); // check
 
     case 'range':
-      return (expr.user_data = (x: UnitRange) => this.CellFunction4(x.start, x.end))(expr); // check
+      return (expr.fn = (x: UnitRange) => this.CellFunction4(x.start, x.end))(expr); // check
 
     case 'binary':
-      return (expr.user_data = this.BinaryExpression(expr))(expr); // check
+      return (expr.fn = this.BinaryExpression(expr))(expr); // check
 
     case 'unary':
-      return (expr.user_data = this.UnaryExpression(expr))(expr); // check
+      return (expr.fn = this.UnaryExpression(expr))(expr); // check
 
     case 'identifier':
-      return (expr.user_data = this.Identifier(expr))(); // check
+      return (expr.fn = this.Identifier(expr))(); // check
 
     case 'missing':
-      return (expr.user_data = () => { return { value: undefined, type: ValueType.undefined } as UndefinedUnion })(); // check
+      return (expr.fn = () => { return { value: undefined, type: ValueType.undefined } as UndefinedUnion })(); // check
 
     case 'dimensioned':
-      return (expr.user_data = this.ResolveDimensionedQuantity())(expr);
+      return (expr.fn = this.ResolveDimensionedQuantity())(expr);
 
     case 'literal':
       {
         const literal = { value: expr.value, type: GetValueType(expr.value) } as UnionValue;
-        return (expr.user_data = () => literal)();  // check
+        return (expr.fn = () => literal)();  // check
       }
     case 'group':
-      return (expr.user_data = this.GroupExpression(expr))(expr); // check
+      return (expr.fn = this.GroupExpression(expr))(expr); // check
 
     case 'complex':
       {
         const literal = {value: {real: expr.real, imaginary: expr.imaginary}, type: ValueType.complex } as ComplexUnion;
-        return (expr.user_data = () => literal)();  // check
+        return (expr.fn = () => literal)();  // check
       }
 
     case 'structured-reference':
-      return (expr.user_data = this.ResolveStructuredReference(expr))();
+      return (expr.fn = this.ResolveStructuredReference(expr))();
 
     case 'array':
       {
-        return (expr.user_data = () => {
+        return (expr.fn = () => {
           return { 
             type: ValueType.array,
             value: expr.values.map((row) => (Array.isArray(row) ? row : [row]).map((value) => {