@trebco/treb 29.3.3 → 29.4.1

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/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);
@@ -408,7 +412,7 @@ export class DataModel {
         (QuotedSheetNameRegex.test(sheet.name) ? `'${sheet.name}'` : sheet.name) : '';
     
     return name + (name ? '!' : '') + (parts[0] === parts[1] ? parts[0] : parts.join(':'));
-    
+
   }
 
   // --- resolution api, moved from calculator ---------------------------------

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;
+    
   }
 
   /**

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

@@ -43,6 +43,7 @@ import type { GridSelection } from './sheet_selection';
 import { CreateSelection } from './sheet_selection';
 import { Annotation } from './annotation';
 import type { ConditionalFormatList } from './conditional_format';
+import type { DataValidation } from './data-validation';
 
 // --- constants --------------------------------------------------------------
 
@@ -163,6 +164,11 @@ export class Sheet {
    */
   public conditional_formats: ConditionalFormatList = [];
 
+  /**
+   * @internal
+   */
+  public data_validation: DataValidation[] = [];
+
   /**
    * @internal
    * 
@@ -255,6 +261,7 @@ export class Sheet {
    */
   private conditional_format_checklist: IArea[] = [];
 
+
   // --- accessors ------------------------------------------------------------
 
   // public get column_header_count() { return this.column_header_count_; }
@@ -383,6 +390,11 @@ export class Sheet {
       sheet.conditional_formats = source.conditional_formats;
     }
 
+    sheet.data_validation = (source.data_validations || []).map(validation => ({
+      ...validation,
+      target: (validation.target||[]).map(target => new Area(target.start, target.end)),
+    }));
+
     // persist ID, name
 
     if (source.id) {
@@ -740,6 +752,45 @@ export class Sheet {
 
   }
 
+  /** add a data validation. */
+  public AddValidation(validation: DataValidation) {
+    this.data_validation.push({
+      ...validation,
+      target: (validation.target||[]).map(target => new Area(target.start, target.end)), // ensure class instance
+    });
+  }
+
+  /** 
+   * remove validations from area. must be an exact match (FIXME).
+   * if there are multiple areas, only remove the matching area.
+   */
+  public RemoveValidations(area: IArea) {
+
+    const check = new Area(area.start, area.end);
+    this.data_validation = this.data_validation.filter(validation => {
+      validation.target = validation.target.filter(compare => !check.Equals2(compare));
+      return validation.target.length > 0;
+    });
+  }
+
+  /** return data validation(s) that apply to a given address */
+  public GetValidation(address: ICellAddress) {
+
+    // switch to imperative
+
+    const list: DataValidation[] = [];
+    for (const entry of this.data_validation) {
+      for (const area of entry.target) {
+        if ((area as Area).Contains(address)) {
+          list.push(entry);
+          break;
+        }
+      }
+    }
+
+    return list;
+
+  }
 
   public Activate(DOM: DOMContext) {
 
@@ -2665,6 +2716,11 @@ export class Sheet {
       JSON.parse(JSON.stringify(this.conditional_formats.map(format => ({...format, internal: undefined })))) : 
       undefined;
 
+    // yes, here. we should have a serialized type so we know to convert. TODO
+
+    const data_validations = this.data_validation.length ? JSON.parse(JSON.stringify(this.data_validation)) : undefined;
+     
+
     const result: SerializedSheet = {
 
       // not used atm, but in the event we need to gate
@@ -2688,6 +2744,7 @@ export class Sheet {
       column_style,
 
       conditional_formats,
+      data_validations,
 
       row_pattern: row_pattern.length ? row_pattern : undefined,
 
@@ -2886,6 +2943,10 @@ export class Sheet {
       this.conditional_formats.push(format);
     }
 
+    for (const validation of data.data_validations || []) {
+      this.AddValidation(validation);
+    }
+
     if (data.hidden) {
       this.visible = false;
     }

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

@@ -23,6 +23,7 @@ import type { IArea, SerializedCellData, CellStyle } from 'treb-base-types';
 import type { AnnotationData } from './annotation';
 import type { GridSelection, SerializedGridSelection } from './sheet_selection';
 import type { ConditionalFormatList } from './conditional_format';
+import type { DataValidation } from './data-validation';
 
 export interface UpdateHints {
   data?: boolean;
@@ -72,6 +73,9 @@ export interface SerializedSheet {
   /** @internal */
   conditional_formats?: ConditionalFormatList;
 
+  /** @internal */
+  data_validations?: DataValidation[];
+
   /** 
    * @deprecated use `styles` instead
    */