@trebco/treb 28.17.5 → 29.1.4

package/treb-calculator/src/primitives.ts

@@ -19,7 +19,7 @@
  * 
  */
 
-import type { Complex, UnionValue} from 'treb-base-types';
+import type { Complex, ComplexUnion, UnionValue} from 'treb-base-types';
 import { ValueType } from 'treb-base-types';
 import { DivideByZeroError, ValueError } from './function-error';
 
@@ -30,7 +30,13 @@ import * as ComplexLib from './complex-math';
 
 export type PrimitiveBinaryExpression = (a: UnionValue, b: UnionValue) => UnionValue;
 
-type NumericTuple = [number, number, UnionValue?, UnionValue?, UnionValue?];
+type NumericTuple = [
+  number, 
+  number, 
+  UnionValue?, // FIXME: should be error type?
+  ComplexUnion?, // UnionValue?, 
+  ComplexUnion?, // UnionValue?
+];
 
 /** 
  * a is either a complex union value or undefined. if it's defined,
@@ -282,31 +288,16 @@ export const Equals = (a: UnionValue, b: UnionValue): UnionValue => {
     return { type: ValueType.boolean, value: true, };
   }
 
-  if (a.type === ValueType.complex || b.type === ValueType.complex) {
-
-    // complex can equal real or complex
-    
-    let equals = false;
-
-    if (a.type === b.type) {
-      equals = 
-        a.value.real == b.value.real &&         // == ?
-        a.value.imaginary == b.value.imaginary  // == ?
-        ;
-    }
-    else if (a.type === ValueType.number) {
-      equals = 
-        b.value.real == a.value  &&
-        !b.value.imaginary;
+  if (a.type === ValueType.complex) {
+    if (b.type === ValueType.complex) {
+      return { type: ValueType.boolean, value: ((a.value.imaginary === b.value.imaginary) && (a.value.real === b.value.real)) };
     }
-    else if (b.type === ValueType.number) {
-      equals = 
-        a.value.real == b.value  &&
-        !a.value.imaginary;
+    else {
+      return { type: ValueType.boolean, value: ((!a.value.imaginary) && (a.value.real === b.value)) };
     }
-
-    return { type: ValueType.boolean, value: equals };
-
+  }
+  else if (b.type === ValueType.complex) {
+    return { type: ValueType.boolean, value: ((!b.value.imaginary) && (a.value === b.value.real)) };
   }
 
   // this is standard (icase) string equality. we might also need
@@ -380,37 +371,57 @@ export const GreaterThan = (a: UnionValue, b: UnionValue): UnionValue => {
   return { type: ValueType.boolean, value: (a.value||0) > (b.value||0) };
 };
 
+const Comparable = (a: UnionValue, b: UnionValue) => {
+
+  if (a.type === ValueType.complex ||
+    a.type === ValueType.array ||
+    a.type === ValueType.dimensioned_quantity ||
+    a.type === ValueType.object ||
+    b.type === ValueType.complex ||
+    b.type === ValueType.array ||
+    b.type === ValueType.dimensioned_quantity ||
+    b.type === ValueType.object 
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
 export const GreaterThanEqual = (a: UnionValue, b: UnionValue): UnionValue => {
   if (a.type === ValueType.error) { return a; }
   if (b.type === ValueType.error) { return b; }
 
-  if (a.type === ValueType.complex || b.type === ValueType.complex) {
-    return ValueError();
-  }
+  if (!Comparable(a, b)) { return ValueError(); }
+
+  return { type: ValueType.boolean, value: (a.value||0) >= (b.value||0) };
 
-  return { type: ValueType.boolean, value: a.value >= b.value };
 };
 
 export const LessThan = (a: UnionValue, b: UnionValue): UnionValue => {
   if (a.type === ValueType.error) { return a; }
   if (b.type === ValueType.error) { return b; }
 
-  if (a.type === ValueType.complex || b.type === ValueType.complex) {
-    return ValueError();
-  }
+  if (!Comparable(a, b)) { return ValueError(); }
+
+  //if (a.type === ValueType.complex || b.type === ValueType.complex) {
+  //  return ValueError();
+  //}
 
-  return { type: ValueType.boolean, value: a.value < b.value };
+  return { type: ValueType.boolean, value: (a.value||0) < (b.value||0) };
 };
 
 export const LessThanEqual = (a: UnionValue, b: UnionValue): UnionValue => {
   if (a.type === ValueType.error) { return a; }
   if (b.type === ValueType.error) { return b; }
 
-  if (a.type === ValueType.complex || b.type === ValueType.complex) {
-    return ValueError();
-  }
+  //if (a.type === ValueType.complex || b.type === ValueType.complex) {
+  //  return ValueError();
+  //}
+
+  if (!Comparable(a, b)) { return ValueError(); }
 
-  return { type: ValueType.boolean, value: a.value <= b.value };
+  return { type: ValueType.boolean, value: (a.value||0) <= (b.value||0) };
 };
 
 export const UseComplex = () => {

package/treb-calculator/src/utilities.ts

@@ -19,12 +19,12 @@
  * 
  */
 
-import type { ArrayUnion, UnionValue} from 'treb-base-types';
+import type { ArrayUnion, CellValue, UnionValue} from 'treb-base-types';
 import { ValueType } from 'treb-base-types';
 
 export const DAY_MS = 1000 * 60 * 60 * 24;
 
-export const IsArrayOrTypedArray = (test: any): boolean => {
+export const IsArrayOrTypedArray = (test: unknown): boolean => {
   return Array.isArray(test) || (test instanceof Float64Array) || (test instanceof Float64Array);
 };
 
@@ -45,19 +45,21 @@ export const Transpose2 = <T> (arr: T[][]): T[][] => {
 
 };
 
-export const TransposeArray = (arr: any[][]) => {
+export const TransposeArray = <T>(arr: T[][]): T[][] => {
 
   if (!arr) return [];
   if (typeof arr[0] === 'undefined') return [];
 
+  /*
   if (!IsArrayOrTypedArray(arr[0])) {
     if (arr instanceof Float32Array || arr instanceof Float64Array){
-      return Array.prototype.slice.call(arr).map((x: any) => [x]);
+      return Array.prototype.slice.call(arr).map((x: T) => [x]);
     }
     return arr.map((x) => [x]);
   }
+  */
 
-  const tmp: any = [];
+  const tmp: T[][] = [];
   const cols = arr.length;
   const rows = arr[0].length;
   for (let r = 0; r < rows; r++) {
@@ -66,6 +68,7 @@ export const TransposeArray = (arr: any[][]) => {
       tmp[r][c] = arr[c][r];
     }
   }
+
   return tmp;
 
 };
@@ -101,7 +104,7 @@ export const ColumnToString = (column: number) => {
 
 export const OffsetFormula = (formula: string, offset: {columns: number, rows: number}) => {
 
-  const cache: any = {};
+  const cache: Record<string, string> = {};
   formula = formula.replace(/\b([A-Za-z]+)(\d+)\b/g, (m, p1, p2) => {
     if (!cache[m]) {
       const c = ColumnToString(StringToColumn(p1) + offset.columns);
@@ -145,21 +148,67 @@ export const FlattenBoxed = (args: UnionValue[]): UnionValue[] => {
 
 };
 
-/**
+/* *
  * flatten a set of arguments
  * UPDATE: we no longer accept the "arguments" object. must be an array.
  * callers can use rest spread to collect arguments.
- */
-export const FlattenUnboxed = (args: any[]): any[] => {
+ * 
+ * @deprecated - use a better-typed version
+ * /
+export const FlattenCellValues = (args: any[]): any[] => {
   if (!Array.isArray(args)) { return [args]; } // special case
   return args.reduce((a: any[], b: any) => {
     if (typeof b === 'undefined') return a;
-    if (Array.isArray(b)) return a.concat(FlattenUnboxed(b));
+    if (Array.isArray(b)) return a.concat(FlattenCellValues(b));
     if (b instanceof Float32Array) return a.concat(Array.from(b));
     if (b instanceof Float64Array) return a.concat(Array.from(b));
     return a.concat([b]);
   }, []);
 };
+*/
+
+/**
+ * specialization using the CellValue type. this should be preferable
+ * to using any, although we're still kind of hacking at it. also we
+ * need to allow typed arrays (I think we've mostly gotten those out?)
+ */
+export const FlattenCellValues = (args: (CellValue|CellValue[]|CellValue[][]|Float32Array|Float64Array)[]): CellValue[] => {
+
+  if (!Array.isArray(args)) { return [args]; } // special case
+  return args.reduce((a: CellValue[], b) => {
+    if (typeof b === 'undefined') return a;
+    if (Array.isArray(b)) return a.concat(FlattenCellValues(b));
+    if (b instanceof Float32Array) return a.concat(Array.from(b));
+    if (b instanceof Float64Array) return a.concat(Array.from(b));
+    return a.concat([b]);
+  }, []);
+
+};
+
+/**
+ * flatten cell values, and filter out any non-numbers. this version does
+ * not account for booleans (you might want TRUE = 1). we do this a lot so
+ * combining the two operations seems like a useful place to reuse code.
+ */
+export const FlattenNumbers = (args: Parameters<typeof FlattenCellValues>[0]) => 
+  (FlattenCellValues(args)).filter((value): value is number => typeof value === 'number');
+
+export const FilterIntrinsics = (data: unknown[]): (string|number|boolean|undefined)[] => {
+  return data.filter((value): value is number|boolean|undefined|string => {
+    switch (typeof value) {
+      case 'number':
+      case 'undefined':
+      case 'string':
+      case 'boolean':
+        return true;
+    }
+    return false;
+  });
+};
+
+/*
+
+// anyone using this? (...) removing
 
 export const UndefinedToEmptyString = (args: any[]): any[] => {
   for (let i = 0; i < args.length; i++) {
@@ -172,150 +221,84 @@ export const UndefinedToEmptyString = (args: any[]): any[] => {
   }
   return args;
 };
+*/
+
+/** type guard. FIXME: move */
+const IsArrayUnion = (value: unknown): value is ArrayUnion => {
+  return (!!value && typeof value === 'object' && (value as { type: ValueType, value?: Array<unknown> }).type === ValueType.array);
+};
 
 /**
- * returns a function that applies the given function to a scalar or a matrix
- * @param base the underlying function
+ * this is an attempt at a generalized array application wrapper 
+ * for functions. the rules are the same -- we apply functions pairwise
+ * (or tuple-wise), not combinatorially.
+ * 
+ * we could simplify a bit if we require that functions used boxed
+ * values. we should do that anyway, and be consistent across functions.
+ * also we could get the `any`s out.
+ * 
+ * (swapping param order, so we don't have hanging param after inline 
+ * function definition -- shades of window.setTimeout)
+ * 
+ * @param map - a list of parameters, by index, that can be unrolled. this
+ * allows us to support both out-of-order application and functions that take
+ * mixes of scalars and arrays.
+ * 
+ * @param base - the underlying function. for any parameters that can
+ * be applied/unrolled, it should take a scalar. 
+ * 
  */
-export const ApplyArrayFunc = (base: (...args: any[]) => any) => {
-  return (a: any) => {
-    if (Array.isArray(a)) {
-      const tmp: any[] = [];
-      const rows = a[0].length;
-      for (let c = 0; c < a.length; c++) {
-        const col: any[] = [];
-        for (let r = 0; r < rows; r++) col[r] = base(a[c][r]);
-        tmp.push(col);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const ApplyArrayX = <TFunc extends (...args: any[]) => UnionValue>(map: boolean[], base: TFunc): (...args: Parameters<TFunc>) => UnionValue => {
+
+  return (...args: Parameters<TFunc>) => {
+
+    // we need to look at the actual parameters passed, not the signature.
+    // spreadsheet language supports "extra" parameters. we usually just 
+    // repeat the tail parameter, but in this case we will NOT repeat the 
+    // application (why not?)
+
+    const arrays: unknown[][][] = [];
+
+    // the result needs to be the same shape as the input. so we use the 
+    // first array we find to create this map.
+
+    let shape: unknown[][] = [];
+    
+    for (const [i, arg] of args.entries()) {
+      if (arg && map[i]) {
+        const arr = Array.isArray(arg) ? arg : IsArrayUnion(arg) ? arg.value : undefined;
+        if (arr) {
+          arrays[i] = arr;
+          if (!shape.length) {
+            shape = arr;
+          }
+        }
       }
-      return tmp;
-    }
-    return base(a);
-  };
-};
-
-export const ApplyAsArraySwap = (base: (...args: any[]) => UnionValue) => {
-  return (...args: any[]): UnionValue => {
-
-    // swap here
-    args.reverse();
-    const [a, ...rest] = args;
-
-    if (Array.isArray(a)) {
-      return {
-        type: ValueType.array,
-        value: a.map(row => row.map((element: any) => {
-
-          // swap back
-          const swapped = [...rest, element];
-          return base(...swapped);
-
-        })),
-      };
     }
-    else if (typeof a === 'object' && !!a && a.type === ValueType.array ) {
-      return {
-        type: ValueType.array,
-        value: (a as ArrayUnion).value.map(row => row.map((element: any) => {
 
-          const swapped = [...rest, element];
-          return base(...swapped);
+    if (arrays.length) {
 
-        })),
-      };
-      
-    }
-    else {
-      return base(...rest, a);
-    }
-  }
-};
+      // this is pretty, but 3 functional loops? ouch
 
-export const ApplyAsArray = (base: (a: any, ...rest: any[]) => UnionValue) => {
-  return (a: any, ...rest: any[]): UnionValue => {
-    if (Array.isArray(a)) {
       return {
         type: ValueType.array,
-        value: a.map(row => row.map((element: any) => {
-          return base(element, ...rest);
+        value: shape.map((_, i) => _.map((_, j) => {
+          const apply = args.map((arg, index) => arrays[index] ? (arrays[index][i][j] || { type: ValueType.undefined }) : arg);
+          return base(...apply as Parameters<TFunc>);
         })),
       };
-    }
-    else if (typeof a === 'object' && !!a && a.type === ValueType.array ) {
-      return {
-        type: ValueType.array,
-        value: (a as ArrayUnion).value.map(row => row.map((element: any) => {
-          return base(element, ...rest);
-        })),
-      };
-      
-    }
-    else {
-      return base(a, ...rest);
-    }
-  }
-};
-
-export const ApplyAsArray2 = (base: (a: any, b: any, ...rest: any[]) => UnionValue) => {
-  return (a: any, b: any, ...rest: any[]): UnionValue => {
 
-    // do we need to worry about unboxed values? probably
-    // what about combinations of boxed/unboxed (implying there are 4)
-
-    // we could simplify this by pulling out the lists...
-
-    let a_array = false;
-    let b_array = false;
-
-    if (!!a && typeof a === 'object' && a.type === ValueType.array) {
-      a = (a as ArrayUnion).value;
-      a_array = true; // don't test again
-    }
-    else {
-      a_array = Array.isArray(a);
     }
 
-    if (!!b && typeof b === 'object' && b.type === ValueType.array) {
-      b = (b as ArrayUnion).value;
-      b_array = true; // don't test again
-    }
-    else {
-      b_array = Array.isArray(b);
-    }
+    // scalar case
 
-    if (a_array){
-      if (b_array) {
-        // a and b are arrays
-        return {
-          type: ValueType.array,
-          value: a.map((row: any[], i: number) => row.map((element: any, j: number) => {
-            return base(element, b[i][j], ...rest);
-          })),
-        };
-      }
-      // a is array, b is scalar
-      return {
-        type: ValueType.array,
-        value: a.map((row: any[]) => row.map((element: any) => {
-          return base(element, b, ...rest);
-        })),
-      };
-    }
-    else if (b_array) {
-      // a is scalar, b is array
-      return {
-        type: ValueType.array,
-        value: b.map((row: any[]) => row.map((element: any) => {
-          return base(a, element, ...rest);
-        })),
-      };
-    }
+    return base(...args);
 
-    return base(a, b, ...rest);
+  };
 
-  }
 };
 
-
 /**
  * parse a string with wildcards into a regex pattern
  * 

package/treb-charts/src/chart-functions.ts

@@ -27,7 +27,7 @@ import type { FunctionMap } from 'treb-calculator/src/descriptors';
  * 
  * UPDATE: box this properly as "extended" type 
  */
-const Identity = (...args: any[]): UnionValue => {
+const Identity = (...args: unknown[]): UnionValue => {
   return {
     type: ValueType.object,
     value: args,
@@ -45,7 +45,7 @@ export const ChartFunctions: FunctionMap = {
     arguments: [
       { name: 'Array...', metadata: true, },
     ],
-    fn: (...args: any) => {
+    fn: (...args: unknown[]) => {
       return {
         type: ValueType.object,
         value: args,
@@ -75,7 +75,7 @@ export const ChartFunctions: FunctionMap = {
       { name: 'subtype', },
       { name: 'Labels', description: 'Labels for bubble charts only (atm)' },
     ],
-    fn: (...args: any) => {
+    fn: (...args: unknown[]) => {
       return {
         type: ValueType.object,
         value: args,

package/treb-charts/src/chart-types.ts

@@ -21,6 +21,47 @@
 
 import type { RangeScale } from 'treb-utils';
 import type { Area } from './rectangle';
+import type { UnitAddress } from 'treb-parser';
+import { ValueType, type ArrayUnion, type CellValue, type ExtendedUnion, type UnionValue } from 'treb-base-types';
+
+export interface ReferenceMetadata {
+  type: 'metadata';
+  address: UnitAddress;
+  value: CellValue;
+  format?: string;
+}
+
+export interface ReferenceSeries extends ExtendedUnion {
+  key: 'series',
+  value: [
+    CellValue?, // { name: 'Label' }, // , metadata: true, },
+    UnionValue?, // { name: 'X', metadata: true, },
+    UnionValue?, // { name: 'Y', metadata: true, },
+    UnionValue?, // { name: 'Z', metadata: true, },
+    CellValue?, // { name: 'index', },
+    CellValue?, // { name: 'subtype', },
+    CellValue?, // { name: 'Labels', description: 'Labels for bubble charts only (atm)' },
+  ];
+}
+
+export const IsMetadata = (value?: unknown): value is ExtendedUnion & { value: ReferenceMetadata } => {
+  return (!!value && (typeof value === 'object') 
+    && (value as ExtendedUnion).key === 'metadata'
+    && !!(value as ExtendedUnion).value
+    && (value as { value: ReferenceMetadata}).value.type === 'metadata');
+};
+
+export const IsSeries = (value?: unknown): value is ReferenceSeries => {
+  return (!!value && (typeof value === 'object')
+    && (value as ReferenceSeries).key === 'series'
+    && Array.isArray((value as ReferenceSeries).value));
+};
+
+export const IsArrayUnion = (value?: unknown): value is ArrayUnion => {
+  return (!!value && (typeof value === 'object')
+    && (value as UnionValue).type === ValueType.array
+    && Array.isArray((value as ArrayUnion).value));
+};
 
 export type NumberOrUndefinedArray = Array<number|undefined>;
 
@@ -44,7 +85,7 @@ export interface CalloutType {
 
 export interface CellData {
   address: { row: number; column: number };
-  value?: any;
+  value?: unknown;
   format?: string;
 }