@trebco/treb 28.17.5 → 29.1.4

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

@@ -20,7 +20,6 @@
  */
 
 import type { RenderFunctionOptions, ClickFunctionOptions, ClickFunctionResult, RenderFunctionResult } from 'treb-base-types';
-import { Style } from 'treb-base-types';
 
 export const ClickCheckbox = (options: ClickFunctionOptions): ClickFunctionResult => {
   const { x, y, width, height, cell } = options;

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

@@ -20,12 +20,14 @@
  */
 
 import type { FunctionMap } from '../descriptors';
-import type { NumberUnion, UnionValue} from 'treb-base-types';
+import type { CellValue, NumberUnion, UnionValue} from 'treb-base-types';
 import { IsComplex, ValueType } from 'treb-base-types';
-import * as Utils from '../utilities';
+// import * as Utils from '../utilities';
 import { ValueError } from '../function-error';
 import { RectangularToPolar } from '../complex-math';
 
+import { CoerceComplex } from './function-utilities';
+
 export const ComplexFunctionLibrary: FunctionMap = {
 
   IsComplex: {
@@ -33,22 +35,23 @@ export const ComplexFunctionLibrary: FunctionMap = {
     arguments: [{
       name: 'Reference',
       metadata: true, /* OK with array metadata */
+      unroll: true,
     }],
-    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
+    fn: (ref: UnionValue): UnionValue => {
       return { 
         type: ValueType.boolean, 
-        value: ref?.value && IsComplex(ref.value.value),
+        value: !!(ref?.value) && IsComplex((ref.value as {value?: CellValue}).value),
       };
-    }),
+    },
   },
 
 
   Real: {
     description: 'Returns the real part of a complex number',
     arguments: [
-      { boxed: true },
+      { boxed: true, unroll: true },
     ],
-    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
+    fn: (ref: UnionValue): UnionValue => {
       if (ref.type === ValueType.number) {
         return { ...ref };
       }
@@ -65,15 +68,15 @@ export const ComplexFunctionLibrary: FunctionMap = {
         };
       }
       return ValueError();
-    }),
+    },
   },
 
   Imaginary: {
     description: 'Returns the imaginary part of a complex number (as real)',
     arguments: [
-      { boxed: true },
+      { boxed: true, unroll: true, },
     ],
-    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
+    fn: (ref: UnionValue): UnionValue => {
       if (ref.type === ValueType.complex) {
         return {
           type: ValueType.number,
@@ -89,41 +92,46 @@ export const ComplexFunctionLibrary: FunctionMap = {
         };
       }
       return ValueError();
-    }),
+    },
   },
 
   Conjugate: {
     description: 'Returns the conjugate of a complex number',
     arguments: [
-      { boxed: true },
+      { boxed: true, unroll: true },
     ],
-    fn: Utils.ApplyAsArray((arg: UnionValue): UnionValue => {
-      if (arg.type === ValueType.complex) {
+    fn: (arg: UnionValue): UnionValue => {
+
+      const complex = CoerceComplex(arg);
+
+      if (!complex) {
+        return ValueError();
+      }
+
+      if (complex.imaginary) {
         return {
           type: ValueType.complex,
           value: {
-            real: arg.value.real,
-            imaginary: -arg.value.imaginary,
+            real: complex.real,
+            imaginary: -complex.imaginary,
           },
-        };
-      }
-      else if (arg.type === ValueType.number || arg.type === ValueType.undefined || !arg.value) {
-        return {
-          type: ValueType.number, value: arg.value || 0,
-        };
-      }
-      else {
-        return ValueError();
+        }
       }
-    }),
+
+      return {
+        type: ValueType.number,
+        value: complex.real,
+      };
+
+    },
   },
 
   Arg: {
     description: 'Returns the principal argument of a complex number (in radians)',
     arguments: [
-      { boxed: true },
+      { boxed: true, unroll: true },
     ],
-    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
+    fn: (ref: UnionValue): UnionValue => {
       
       if (ref.type === ValueType.complex) {
         return {
@@ -142,7 +150,7 @@ export const ComplexFunctionLibrary: FunctionMap = {
       }
 
       return ValueError();
-    }),
+    },
   },
 
   Rectangular: {
@@ -165,30 +173,24 @@ export const ComplexFunctionLibrary: FunctionMap = {
   Complex: {
     description: 'Ensures that the given value will be treated as a complex number',
     arguments: [
-      { boxed: true },
+      { boxed: true, unroll: true },
     ],
 
     // FIXME: this should use flatten? not sure
 
-    fn: Utils.ApplyAsArray((a: UnionValue): UnionValue => {
+    fn: (a: UnionValue): UnionValue => {
       
-      if (a.type === ValueType.complex) {
-        return a;
-      }
-      
-      if (a.type === ValueType.number || a.type === ValueType.undefined || !a.value) {
-        return { 
-          type: ValueType.complex, 
-          value: {
-            imaginary: 0,
-            real: a.value || 0,
-          },
-        }
+      const complex = CoerceComplex(a);
+      if (complex) {
+        return {
+          type: ValueType.complex,
+          value: complex,
+        };
       }
 
       return ValueError();
 
-    }),
+    },
   },
 
   /**
@@ -203,9 +205,9 @@ export const ComplexFunctionLibrary: FunctionMap = {
   ComplexLog: {
     description: 'Returns the principal value Log(z) of a complex number z',
     arguments: [
-      { boxed: true },
+      { boxed: true, unroll: true },
     ],
-    fn: Utils.ApplyAsArray((a: UnionValue): UnionValue => {
+    fn: (a: UnionValue): UnionValue => {
 
       // real -> complex
       if (a.type === ValueType.number) {
@@ -247,7 +249,7 @@ export const ComplexFunctionLibrary: FunctionMap = {
       
       return ValueError();
 
-    }),
+    },
   },
 
 };

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

@@ -21,9 +21,9 @@
 
 import type { FunctionMap } from '../descriptors';
 import { type CellValue, type UnionValue, ValueType } from 'treb-base-types';
-import { FlattenUnboxed } from '../utilities';
+import { FlattenCellValues } from '../utilities';
 
-import { ArgumentError, ReferenceError, UnknownError, ValueError, ExpressionError, NAError, DivideByZeroError } from '../function-error';
+import { ArgumentError, ValueError } from '../function-error';
 
 // use a single, static object for base functions
 
@@ -98,11 +98,11 @@ export const FinanceFunctionLibrary: FunctionMap = {
       { name: 'Rate' },
       { name: 'Cashflow' },
     ],
-    fn: (rate = 0, ...args: any[]): UnionValue => {
+    fn: (rate = 0, ...args: CellValue[]): UnionValue => {
 
       let result = 0;
 
-      const flat = FlattenUnboxed(args);
+      const flat = FlattenCellValues(args);
       for (let i = 0; i < flat.length; i++) {
         const arg = flat[i];
         if (typeof arg === 'number') {
@@ -123,14 +123,14 @@ export const FinanceFunctionLibrary: FunctionMap = {
       { name: 'Values', },
       { name: 'Dates', },
     ],
-    fn: (rate: UnionValue, input_values: CellValue[], input_dates: CellValue[]): UnionValue => {
+    fn: (rate: CellValue, input_values: CellValue[], input_dates: CellValue[]): UnionValue => {
 
       if (typeof rate !== 'number') {
         return ArgumentError();
       }
 
-      input_values = FlattenUnboxed(input_values);
-      input_dates = FlattenUnboxed(input_dates);
+      input_values = FlattenCellValues(input_values);
+      input_dates = FlattenCellValues(input_dates);
 
       // some validation...
 
@@ -186,8 +186,8 @@ export const FinanceFunctionLibrary: FunctionMap = {
     ],
     fn: (input_values: CellValue[], input_dates: CellValue[], guess = .1): UnionValue => {
 
-      input_values = FlattenUnboxed(input_values);
-      input_dates = FlattenUnboxed(input_dates);
+      input_values = FlattenCellValues(input_values);
+      input_dates = FlattenCellValues(input_dates);
 
       // some validation...
 
@@ -307,7 +307,7 @@ export const FinanceFunctionLibrary: FunctionMap = {
     ],
     fn: (args: CellValue[], guess = .1): UnionValue => {
 
-      const flat = FlattenUnboxed(args).map(value => typeof value === 'number' ? value : 0);
+      const flat = FlattenCellValues(args).map(value => typeof value === 'number' ? value : 0);
 
       const step = .1; // initial step
 

package/treb-calculator/src/functions/function-utilities.ts

@@ -0,0 +1,26 @@
+
+import type { UnionValue, Complex } from 'treb-base-types';
+import { ValueType } from 'treb-base-types';
+
+export const CoerceComplex = (value: UnionValue): Complex|false => {
+
+  switch (value.type) {
+    case ValueType.complex: 
+      return value.value;
+
+    case ValueType.number:
+      return { real: value.value, imaginary: 0 };
+
+    case ValueType.boolean:
+      return { real: value.value ? 1 : 0, imaginary: 0 };
+
+    // controversial? ...
+    case ValueType.undefined:
+      return { real: 0, imaginary: 0 };
+
+  }
+      
+  return false;
+
+};
+

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

@@ -21,64 +21,44 @@
 
 import type { FunctionMap } from '../descriptors';
 import { type UnionValue, ValueType } from 'treb-base-types';
-import * as Utils from '../utilities';
+
+const MatchType = (type: string, ref: UnionValue): UnionValue => {
+  return { 
+    type: ValueType.boolean, 
+    value: typeof (ref.value as {value?: unknown})?.value === type,
+  };
+};
+
+const match_arguments = [{
+  name: 'Reference',
+  metadata: true,
+  unroll: true,
+}];
 
 export const InformationFunctionLibrary: FunctionMap = {
 
   IsBlank: {
     description: 'Returns true if the reference is blank',
-    arguments: [{
-      name: 'Reference',
-      metadata: true,
-    }],
-    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
-      return { 
-        type: ValueType.boolean, 
-        value: !ref?.value || typeof ref.value.value === 'undefined',
-      };
-    }),
+    arguments: match_arguments,
+    fn: MatchType.bind(0, 'undefined'),
   },
 
   IsNumber: {
     description: 'Returns true if the reference is a number',
-    arguments: [{
-      name: 'Reference',
-      metadata: true,
-    }],
-    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
-      return { 
-        type: ValueType.boolean, 
-        value: ref?.value && typeof ref.value.value === 'number',
-      };
-    }),
+    arguments: match_arguments,
+    fn: MatchType.bind(0, 'number'),
   },
 
   IsLogical: {
     description: 'Returns true if the reference is a logical TRUE or FALSE',
-    arguments: [{
-      name: 'Reference',
-      metadata: true,
-    }],
-    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
-      return { 
-        type: ValueType.boolean, 
-        value: ref?.value && typeof ref.value.value === 'boolean',
-      };
-    }),
+    arguments: match_arguments,
+    fn: MatchType.bind(0, 'boolean'),
   },
 
   IsText: {
     description: 'Returns true if the reference is text',
-    arguments: [{
-      name: 'Reference',
-      metadata: true,
-    }],
-    fn: Utils.ApplyAsArray((ref: UnionValue): UnionValue => {
-      return { 
-        type: ValueType.boolean, 
-        value: ref?.value && typeof ref.value.value === 'string'
-      };
-    }),
+    arguments: match_arguments,
+    fn: MatchType.bind(0, 'string'),
   },
 
   /* needs more data

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

@@ -37,11 +37,18 @@ const ComplexMatrix = (input: UnionValue): ComplexMatrixType => {
 
   // ensure array
 
+  // hmmm... this is confusing. what is this doing? is this for scalars?
+  // if that were the case shouldn't it wrap up the outer value, and not 
+  // the value property? ...
+
   if (input.type === ValueType.array) {
     a = input.value;
   }
   else {
-    a = [[input.value]];
+
+    // a = [[input.value]];
+    a = [[input]];
+
   }
 
   // if (!Array.isArray(a)) { a = [[a]]; }

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

@@ -30,7 +30,7 @@
  */
 
 
-import type { Cell, Style, CellStyle } from 'treb-base-types';
+import type { Cell, CellStyle } from 'treb-base-types';
 
 export interface SparklineRenderOptions {
   context: CanvasRenderingContext2D;
@@ -62,7 +62,7 @@ export class Sparkline {
    * representation (loading file); in that case it's an object with numeric
    * indexes (sadly)
    */
-  protected static UnpackValues(underlying: any): number[] {
+  protected static UnpackValues(underlying: unknown): number[] {
 
     if (Array.isArray(underlying)) {
       const test = underlying[0];
@@ -85,7 +85,9 @@ export class Sparkline {
       // if (keys.every(key => !isNaN(Number(key)))) {
 
       // check first, last
-      if (typeof underlying['0'] !== 'undefined' && typeof underlying[(len - 1).toString()] !== 'undefined') {
+      if (typeof ((underlying as Record<string, number>)['0']) !== 'undefined' && 
+          typeof (underlying as Record<string, number>)[(len - 1).toString()] !== 'undefined') {
+            
         const data: number[] = [];
 
         // we probably don't have to explicitly use strings -- although it's not
@@ -93,7 +95,7 @@ export class Sparkline {
         // conversion
 
         for (let i = 0; i < len; i++) {
-          data[i] = underlying[i.toString()];
+          data[i] = (underlying as Record<string, number>)[i.toString()];
         }
         return data;
       }

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

@@ -22,7 +22,7 @@
 import type { FunctionMap } from '../descriptors';
 import * as Utils from '../utilities';
 import { ValueError, ArgumentError, NAError } from '../function-error';
-import { type Complex, type UnionValue, ValueType } from 'treb-base-types';
+import { type Complex, type UnionValue, ValueType, type CellValue } from 'treb-base-types';
 import * as ComplexMath from '../complex-math';
 
 export const Variance = (data: number[], sample = false) => {
@@ -58,32 +58,32 @@ export const StatisticsFunctionLibrary: FunctionMap = {
   'StDev.P': {
     description: 'Returns the standard deviation of a set of values, corresponding to a population',
     arguments: [{ name: 'data', }],
-    fn: (...args: any[]): UnionValue => {
-      return { type: ValueType.number, value: Math.sqrt(Variance(Utils.FlattenUnboxed(args), false)) };
+    fn: (...args: CellValue[]): UnionValue => {
+      return { type: ValueType.number, value: Math.sqrt(Variance(Utils.FlattenNumbers(args), false)) };
     },
   },
 
   'StDev.S': {
     description: 'Returns the standard deviation of a set of values, corresponding to a sample of a population',
     arguments: [{ name: 'data', }],
-    fn: (...args: any[]): UnionValue => {
-      return { type: ValueType.number, value: Math.sqrt(Variance(Utils.FlattenUnboxed(args), true)) };
+    fn: (...args: CellValue[]): UnionValue => {
+      return { type: ValueType.number, value: Math.sqrt(Variance(Utils.FlattenNumbers(args), true)) };
     },
   },
 
   'Var.P': {
     description: 'Returns the variance of a set of values, corresponding to a population',
     arguments: [{ name: 'data', }],
-    fn: (...args: any[]): UnionValue => {
-      return { type: ValueType.number, value: Variance(Utils.FlattenUnboxed(args), false) };
+    fn: (...args: CellValue[]): UnionValue => {
+      return { type: ValueType.number, value: Variance(Utils.FlattenNumbers(args), false) };
     },
   },
 
   'Var.S': {
     description: 'Returns the variance of a set of values, corresponding to a sample of a population',
     arguments: [{ name: 'data', }],
-    fn: (...args: any[]): UnionValue => {
-      return { type: ValueType.number, value: Variance(Utils.FlattenUnboxed(args), true) };
+    fn: (...args: CellValue[]): UnionValue => {
+      return { type: ValueType.number, value: Variance(Utils.FlattenNumbers(args), true) };
     },
   },
 
@@ -94,7 +94,7 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     }, {
       name: 'B',
     }],
-    fn: (x: any[], y: any[]): UnionValue => {
+    fn: (x: number[][], y: number[][]): UnionValue => {
 
       // both must be 2d arrays, we're assuming the same or mostly similar shape
       if (!Array.isArray(x) || !Array.isArray(y)) { return ValueError(); }
@@ -153,7 +153,7 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     }, {
       name: 'B',
     }],
-    fn: (x: any[], y: any[]): UnionValue => {
+    fn: (x: number[][], y: number[][]): UnionValue => {
 
       // both must be 2d arrays, we're assuming the same or mostly similar shape
       if (!Array.isArray(x) || !Array.isArray(y)) { return ValueError(); }
@@ -201,7 +201,7 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     description: 'Returns the geometric mean of all numeric arguments',
     arguments: [{ boxed: true }],
 
-    fn: (...args: any[]): UnionValue => {
+    fn: (...args: UnionValue[]): UnionValue => {
 
       args = Utils.FlattenBoxed(args); 
 
@@ -210,7 +210,7 @@ export const StatisticsFunctionLibrary: FunctionMap = {
       let complex = false;
       let negative = false;
 
-      for (const arg of args as UnionValue[]) {
+      for (const arg of args) {
         
         if (arg.type === ValueType.complex) {
           complex = true;
@@ -265,7 +265,7 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     description: 'Returns the arithmetic mean of all numeric arguments',
     arguments: [{ boxed: true }],
 
-    fn: (...args: any[]): UnionValue => {
+    fn: (...args: UnionValue[]): UnionValue => {
       args = Utils.FlattenBoxed(args);
 
       const result = { real: 0, imaginary: 0 };
@@ -305,7 +305,9 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     ],
     fn: (range: number[][], percentile: number): UnionValue => {
 
-      const flat = Utils.FlattenUnboxed(range).filter((test) => typeof test === 'number');
+      // const flat = Utils.FlattenCellValues(range).filter((test): test is number => typeof test === 'number');
+      const flat = Utils.FlattenNumbers(range);
+
       flat.sort((a, b) => a - b);
       const n = flat.length;
 
@@ -326,9 +328,11 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     arguments: [
       { name: 'range' },
     ],
-    fn: (...args: any[]): UnionValue => {
+    fn: (...args: number[]): UnionValue => {
+
+      // const flat = Utils.FlattenCellValues(args).filter((test): test is number => typeof test === 'number');
+      const flat = Utils.FlattenNumbers(args);
 
-      const flat = Utils.FlattenUnboxed(args).filter((test) => typeof test === 'number');
       flat.sort((a, b) => a - b);
       const n = flat.length;
 

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

@@ -19,9 +19,9 @@
  * 
  */
 
-import type { FunctionMap } from '../descriptors';
+import type { FunctionMap, IntrinsicValue } from '../descriptors';
 import { NumberFormatCache, ValueParser } from 'treb-format';
-import type { UnionValue} from 'treb-base-types';
+import type { CellValue, UnionValue} from 'treb-base-types';
 import { Localization, ValueType } from 'treb-base-types';
 import * as Utils from '../utilities';
 import { ArgumentError, ValueError } from '../function-error';
@@ -78,15 +78,15 @@ export const TextFunctionLibrary: FunctionMap = {
   WildcardMatch: {
     visibility: 'internal',
     arguments: [
-      { name: 'text', },
-      { name: 'text', },
+      { name: 'text', unroll: true },
+      { name: 'text', unroll: true },
 
       // the invert parameter is optional, defaults to false. we add this
       // so we can invert wirhout requiring an extra function call.
 
       { name: 'invert' }, 
     ],
-    fn: Utils.ApplyAsArray2((a: any, b: any, invert = false) => {
+    fn: (a: IntrinsicValue, b: IntrinsicValue, invert = false) => {
 
       if (typeof a === 'string' && typeof b === 'string') {
         const pattern = Utils.ParseWildcards(b);
@@ -102,21 +102,22 @@ export const TextFunctionLibrary: FunctionMap = {
         type: ValueType.boolean,
         value: (a === b || a?.toString() === b?.toString()),
       }
-    }),
+    },
+    
   },
 
   Exact: {
     arguments: [
-      { name: 'text', boxed: true, },
-      { name: 'text', boxed: true, },
+      { name: 'text', boxed: true, unroll: true },
+      { name: 'text', boxed: true, unroll: true },
     ],
     category: ['text'],
-    fn: Utils.ApplyAsArray2((a: UnionValue, b: UnionValue): UnionValue => {
+    fn: (a: UnionValue, b: UnionValue): UnionValue => {
       return {
         type: ValueType.boolean,
         value: (a?.value?.toString()) === (b?.value?.toString()),
       };
-    }),
+    },
   },
 
   Left: {
@@ -258,15 +259,15 @@ export const TextFunctionLibrary: FunctionMap = {
   /** canonical should be CONCAT; concatenate can be an alias */
  Concat: {
   description: 'Pastes strings together',
-  fn: (...args: unknown[]): UnionValue => {
+  fn: (...args: CellValue[]): UnionValue => {
 
-    const values = Utils.FlattenUnboxed(args) as unknown[];
+    const values = Utils.FlattenCellValues(args);
     const value = values.map((arg) => {
 
       // this is used when concatenating cells that contain numbers
       // FIXME: get cell number format? we'd need to use metadata
 
-      const string_arg = (arg as any)?.toString() || '';
+      const string_arg = arg?.toString() || '';
 
       if (typeof arg === 'number' && Localization.decimal_separator === ',') {
         return string_arg.replace(/\./, ',');