@trebco/treb 29.3.4 → 29.5.0

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) => {

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

@@ -1936,8 +1936,8 @@ for (const name of Object.getOwnPropertyNames(Math)) {
   case 'function':
     // console.info("MATH FUNC", name);
     BaseFunctionLibrary[name] = {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      fn: (...args: any) => {
+      // description: 'Math function',
+      fn: (...args: unknown[]) => {
         return Box(value(...args));
       },
       category: ['Math Functions'],

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

@@ -30,7 +30,7 @@
  */
 
 
-import type { Cell, CellStyle } from 'treb-base-types';
+import { IsHTMLColor, type Cell, type CellStyle } from 'treb-base-types';
 
 export interface SparklineRenderOptions {
   context: CanvasRenderingContext2D;
@@ -120,7 +120,7 @@ export class Sparkline {
     // theme default _should_ always be passed in, so we should (theoretically)
     // never need our default.
    
-    const text_color = style.text?.text || this.default_color;
+    const text_color = IsHTMLColor(style.text) ? style.text.text : this.default_color;
     const colors: string[] = [ text_color, text_color ];
 
     if (Array.isArray(cell.calculated)) {

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

@@ -343,7 +343,37 @@ export const StatisticsFunctionLibrary: FunctionMap = {
       return { type: ValueType.number, value: (flat[lo-1] + flat[hi-1]) / 2 };
 
     },
-  }
+  },
+
+  Rank: {
+    arguments: [
+      { name: 'Value', },
+      { name: 'Source', },
+      { name: 'Order', },
+    ],
+    fn: (value: number, source: CellValue[], order = 0) => {
+
+      if (typeof value !== 'number') {
+        return ArgumentError();
+      }
+
+      const numbers = Utils.FlattenNumbers(source);
+      numbers.sort(order ? (a, b) => a - b : (a, b) => b - a);
+
+      for (let i = 0; i < numbers.length; i++) {
+        if (numbers[i] === value) {
+          return {
+            type: ValueType.number,
+            value: i + 1,
+          };
+        }
+      }
+
+      return ValueError();
+
+    },
+  },
+
 
 };
 

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

@@ -0,0 +1,44 @@
+
+import type { IArea, CellValue } from 'treb-base-types';
+
+/** @internal */
+export interface DataValidationRange {
+  type: 'range'; 
+  area: IArea;
+}
+
+/** @internal */
+export interface DataValidationList {
+  type: 'list'; 
+  list: CellValue[];
+}
+
+/** @internal */
+export interface DataValidationDate {
+  type: 'date'; 
+}
+
+/** @internal */
+export interface DataValidationNumber {
+  type: 'number'; 
+}
+
+/** @internal */
+export interface DataValidationBoolean {
+  type: 'boolean'; 
+}
+
+/** @internal */
+export type DataValidation 
+  = (DataValidationList
+  | DataValidationRange
+  | DataValidationNumber
+  | DataValidationDate
+  | DataValidationBoolean) & {
+
+  error?: boolean;
+  // target: Area[];  // can be multple so we'll default to array
+  target: IArea[];
+
+}
+

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

@@ -73,7 +73,7 @@ export class DataModel {
   public readonly sheets = new SheetCollection();
 
   /** new composite collection (TODO: add macro functions too?) */
-  public readonly named = new NamedRangeManager();
+  public readonly named = new NamedRangeManager(this.parser);
 
   /** macro functions are functions written in spreadsheet language */
   public readonly macro_functions: Map<string, MacroFunction> = new Map();
@@ -152,15 +152,19 @@ export class DataModel {
             [ parse_result.expression, parse_result.expression ];
 
           if (start.sheet) {
-            const area = new Area({...start, sheet_id: this.sheets.ID(start.sheet), }, end);
-  
-            if (area.start.sheet_id) {
-              this.named.SetNamedRange(named.name, area, scope);
+            if (/^\[\d+\]/.test(start.sheet)) {
+              console.warn('named range refers to an external file');
             }
             else {
-              console.warn("missing sheet ID?", start);
+              const area = new Area({...start, sheet_id: this.sheets.ID(start.sheet), }, end);
+    
+              if (area.start.sheet_id) {
+                this.named.SetNamedRange(named.name, area, scope);
+              }
+              else {
+                console.warn("missing sheet ID?", start);
+              }
             }
-
           }
           else {
             console.warn("missing sheet name?", start);

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

@@ -42,4 +42,4 @@ export { Annotation } from './annotation';
 export type { ViewData as AnnotationViewData } from './annotation';
 export type { AnnotationData, AnnotationType } from './annotation';
 
-
+export * from './data-validation';

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

@@ -21,7 +21,7 @@
 
 import { Area } from 'treb-base-types';
 import type { IArea } from 'treb-base-types';
-import type { ExpressionUnit } from 'treb-parser';
+import type { ExpressionUnit, Parser } from 'treb-parser';
 
 interface NamedExpression {
   type: 'expression';
@@ -82,6 +82,8 @@ export class NamedRangeManager {
     return this.named.values();
   }
 
+  constructor(public parser: Parser) {}
+
   /** shorthand for setting named expression */
   public SetNamedExpression(name: string, expression: ExpressionUnit, scope?: number) {
     return this.SetName({
@@ -206,30 +208,53 @@ export class NamedRangeManager {
    * named range rules:
    *
    * - legal characters are alphanumeric, underscore and dot.
+   * 
    * - must start with letter or underscore (not a number or dot).
+   *   UPDATE: also possibly a backslash? not sure if that's escaping or not.
+   * 
    * - cannot look like a spreadsheet address, which is 1-3 letters followed by numbers.
-   *
+   *   UPDATE: actually this is legal if the number is "0". that's the only
+   *   number. I don't think our parser will process this correctly, so until
+   *   then keep it illegal.
+   * 
    * - apparently questuon marks are legal, but not in first position. atm 
    *   our parser will reject.
    * 
+   * - FIXME: we should block R1C1-looking notation as well
+   * 
    * returns a normalized name (just caps, atm)
    */
   public ValidateNamed(name: string): string|false {
-    name = name.trim();
+
+    // normalize
+    name = name.trim().toUpperCase();
 
     // can't be empty
     if (!name.length) return false;
 
-    // can't look like a spreadsheet address
-    if (/^[A-Za-z]{1,3}\d+$/.test(name)) return false;
-
-    // can only contain legal characters
-    if (/[^A-Za-z\d_.?]/.test(name)) return false;
+    // can only contain legal characters [FIXME: backslash is legal?]
+    if (/[^A-Z\d_.?]/.test(name)) return false;
 
     // must start with ascii letter or underscore
-    if (/^[^A-Za-z_]/.test(name)) return false;
+    if (/^[^A-Z_]/.test(name)) return false;
+
+    // these are not legal for some reason -- they look like R1C1?
+    if (name === 'R' || name === 'C') {
+      return false;
+    }
+
+    // FIXME: should we just use a parser? we're adding more and more regexes.
+
+    // can't look like a spreadsheet address, unless the row is === 0
+    if (/^[A-Z]{1,3}[1-9]\d*$/.test(name)) return false;
+
+    // can't look like R1C1 either (we already checked for R and C)
+    if (/^R[[\]\d]+C/.test(name)) {
+      return false;
+    }
 
-    return name.toUpperCase();
+    return name;
+    
   }
 
   /**