@trebco/treb 28.17.5 → 29.1.2

package/treb-calculator/src/descriptors.ts

@@ -34,7 +34,7 @@ export interface ArgumentDescriptor {
 
   name?: string;
   description?: string;
-  default?: any;
+  default?: number|string|boolean;
 
   // moved from function arrays:
 
@@ -70,6 +70,15 @@ export interface ArgumentDescriptor {
    */
   metadata?: boolean;
 
+  /**
+   * new flag for automating array application. set this flag to allow
+   * unrolling of array parameters. @see ApplyArray in `utilities.ts`.
+   * 
+   * if this flag is set in any argument descriptor in a function, we'll
+   * apply arrays. that's done when the function is installed. 
+   */
+  unroll?: boolean;
+
 }
 
 /**
@@ -108,8 +117,13 @@ export interface CompositeFunctionDescriptor {
   /**
    * the actual function. if this is an object member and needs access
    * to the containing instance, make sure to bind it to that instance.
+   * 
+   * FIXME: this should change to unknown, but that's going to cause 
+   * a lot of issues
+   * 
    */
-  fn: (...args: any[]) => UnionValue; // UnionOrArray; // |UnitAddress|UnitRange;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  fn: (...args: any[]) => UnionValue; 
 
   /**
    * limited visibility
@@ -152,8 +166,18 @@ export interface CompositeFunctionDescriptor {
   /**
    * @internal
    */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   export?: (...args: any[]) => string;
 
+  /**
+   * flag indicating we've unrolled this function. it's possible functions
+   * will run through the registration process more than once and we don't
+   * want to have extra depth.
+   * 
+   * @internal
+   */
+  unrolled?: boolean;
+
 }
 
 export interface FunctionMap {
@@ -172,3 +196,5 @@ export interface ExtendedFunctionDescriptor extends CompositeFunctionDescriptor
 export interface ExtendedFunctionMap {
   [index: string]: ExtendedFunctionDescriptor;
 }
+
+export type IntrinsicValue = number|string|boolean|undefined;

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

@@ -21,20 +21,22 @@
 
 import type { FunctionLibrary } from './function-library';
 import type { Cell, ICellAddress,
-         Area, UnionValue, CellValue,
+         UnionValue, CellValue,
          ArrayUnion,
          NumberUnion,
          UndefinedUnion,
-         ComplexUnion } from 'treb-base-types';
+         ComplexUnion, 
+         DimensionedQuantityUnion} from 'treb-base-types';
 import { ValueType, GetValueType } 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-grid';
+import type { DataModel, MacroFunction, Sheet } from 'treb-data-model';
 import { NameError, ReferenceError, ExpressionError, UnknownError } from './function-error';
 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
 
 // FIXME: move
@@ -96,7 +98,7 @@ export class ExpressionCalculator {
   // protected sheet_name_map: {[index: string]: number} = {};
 
   // local reference
-  protected named_range_map: {[index: string]: Area} = {};
+  // protected named_range_map: {[index: string]: Area} = {};
 
   // protected bound_name_stack: Array<Record<string, ExpressionUnit>> = [];
 
@@ -123,7 +125,7 @@ export class ExpressionCalculator {
     */
 
     this.data_model = model;
-    this.named_range_map = model.named_ranges.Map();
+    // this.named_range_map = model.named_ranges.Map();
     this.context.model = model;
     
   }
@@ -216,6 +218,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*/ {
 
     // FIXME: we used to restrict this to non-cell functions, now
@@ -250,13 +253,14 @@ export class ExpressionCalculator {
 
     case 'identifier':
       {
-        const named_range = this.named_range_map[arg.name.toUpperCase()];
-        if (named_range) {
-          if (named_range.count === 1) {
-            address = named_range.start; // FIXME: range?
+        // 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) {
+            address = named_range.area.start; // FIXME: range?
           }
           else {
-            range = named_range;
+            range = named_range.area;
           }
         }
       }
@@ -726,7 +730,7 @@ export class ExpressionCalculator {
           value: expression.value,
           unit: expr.unit.name,
         },
-      };
+      } as DimensionedQuantityUnion;
     };
 
   }
@@ -938,30 +942,22 @@ export class ExpressionCalculator {
       }
       */
 
-      const named_range = this.named_range_map[upper_case];
+      // 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) {
-        if (named_range.count === 1) {
-          return this.CellFunction4(named_range.start, named_range.start);
+      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.start, named_range.end);
+          return this.CellFunction4(named_range.area.start, named_range.area.end);
         }
       }
 
-      const named_expression = this.data_model.named_expressions.get(upper_case); 
-      if (named_expression) {
-        return this.CalculateExpression(named_expression as ExtendedExpressionUnit);
-      }
-
-      /*
-      const bound_names = this.context.name_stack[0];
-
-      if (bound_names && bound_names[upper_case]) {
-        const bound_expression = bound_names[upper_case];
-        return this.CalculateExpression(bound_expression);
+      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);
       }
-      */
 
       // console.info( '** identifier', {identifier, expr, context: this.context});
       
@@ -1052,16 +1048,11 @@ export class ExpressionCalculator {
         return (expr.user_data = () => {
           return { 
             type: ValueType.array,
-            value: expr.values.map((row: any) => (Array.isArray(row) ? row : [row]).map((value: any) => {
+            value: expr.values.map((row) => (Array.isArray(row) ? row : [row]).map((value) => {
               return { type: GetValueType(value), value } as UnionValue;
             })),
           } as ArrayUnion;
         })();
-        /*
-        return (expr.user_data = () => expr.values.map(row => (Array.isArray(row) ? row : [row]).map(value => {
-          return { value, type: GetValueType(value) }
-        })))(); // check
-        */
       }
 
     default:

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

@@ -19,7 +19,7 @@
  * 
  */
 
-import type { UnionValue} from 'treb-base-types';
+import type { ErrorUnion, UnionValue} from 'treb-base-types';
 import { ValueType } from 'treb-base-types';
 
 export enum ErrorType {
@@ -70,7 +70,7 @@ export const ArgumentError = (): UnionValue => {
   return { type: ValueType.error, value: ErrorType.Argument };
 };
 
-export const ValueError = (): UnionValue => {
+export const ValueError = (): /* UnionValue */ ErrorUnion => {
   return { type: ValueType.error, value: ErrorType.Value };
 };
 

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

@@ -22,6 +22,7 @@
 import type { 
   ExtendedFunctionDescriptor, CompositeFunctionDescriptor,
   FunctionMap, ExtendedFunctionMap } from './descriptors';
+import { ApplyArrayX } from './utilities';
 
 /**
  * singleton (static instance) of function library; includes utility methods
@@ -66,6 +67,21 @@ export class FunctionLibrary {
         const descriptor = map[name] as ExtendedFunctionDescriptor;
         descriptor.canonical_name = name;
 
+        if (!descriptor.unrolled) {
+
+          // potentially apply a wrapper to unroll loops
+
+          const unroll = descriptor.arguments?.map(test => !!test.unroll);
+          if (unroll?.some(value => !!value)) {
+            descriptor.fn = ApplyArrayX(unroll, descriptor.fn);
+            descriptor.unrolled = true;
+          }
+
+          // we could set that flag even if we don't do anything,
+          // sp we don't check again (minor optimization)
+
+        }
+
         this.functions[normalized] = descriptor;
       }