@trebco/treb 28.13.2 → 28.15.1

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v28.13. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v28.15. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map
@@ -1077,7 +1077,7 @@ export interface FreezePane {
     rows: number;
     columns: number;
 }
-export type AnnotationType = 'treb-chart' | 'image' | 'external';
+export type AnnotationType = 'treb-chart' | 'image' | 'textbox' | 'external';
 export declare type BorderConstants = "none" | "all" | "outside" | "top" | "bottom" | "left" | "right";
 
 /**
@@ -1274,6 +1274,9 @@ export interface CellStyle {
     /** border color */
     border_bottom_fill?: Color;
 
+    /** text indent */
+    indent?: number;
+
     /**
      * cell is locked for editing
      */
@@ -1805,7 +1808,7 @@ export interface SerializedGridSelection {
     /** for cacheing addtional selections. optimally don't serialize */
     rendered?: boolean;
 }
-export type AnnotationData = AnnotationChartData | AnnotationImageData | AnnotationExternalData;
+export type AnnotationData = AnnotationChartData | AnnotationImageData | AnnotationExternalData | AnnotationTextBoxData;
 export interface ImageSize {
     width: number;
     height: number;
@@ -1888,6 +1891,19 @@ export interface AnnotationImageData extends AnnotationDataBase {
 export interface AnnotationChartData extends AnnotationDataBase {
     type: 'treb-chart';
 }
+export interface AnnotationTextBoxData extends AnnotationDataBase {
+    type: 'textbox';
+    data: {
+        style?: CellStyle;
+        paragraphs: {
+            style?: CellStyle;
+            content: {
+                text: string;
+                style?: CellStyle;
+            }[];
+        }[];
+    };
+}
 export interface AnnotationExternalData extends AnnotationDataBase {
     type: 'external';
     data: Record<string, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trebco/treb",
-  "version": "28.13.2",
+  "version": "28.15.1",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {

package/treb-base-types/src/style.ts

@@ -145,6 +145,9 @@ export interface CellStyle {
   /** border color */
   border_bottom_fill?: Color;
 
+  /** text indent */
+  indent?: number;
+
   /**
    * cell is locked for editing
    * 

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

@@ -806,15 +806,11 @@ export class ExpressionCalculator {
 
   }
 
-  //protected ElementwiseBinaryExpression(fn: Primitives.PrimitiveBinaryExpression, left: UnionValue[][], right: UnionValue[][]): UnionValue[][] {
   protected ElementwiseBinaryExpression(fn: Primitives.PrimitiveBinaryExpression, left: ArrayUnion, right: ArrayUnion): ArrayUnion {
 
     const columns = Math.max(left.value.length, right.value.length);
     const rows = Math.max(left.value[0].length, right.value[0].length);
 
-    // const columns = Math.max(left.length, right.length);
-    // const rows = Math.max(left[0].length, right[0].length);
-
     const left_values = this.RecycleArray(left.value, columns, rows);
     const right_values = this.RecycleArray(right.value, columns, rows);
 
@@ -822,8 +818,16 @@ export class ExpressionCalculator {
 
     for (let c = 0; c < columns; c++) {
       const col: UnionValue[] = [];
+
       for (let r = 0; r < rows; r++ ) {
-        col[r] = fn(left_values[c][r], right_values[c][r]);
+
+        // handle undefineds. this is unfortunate. shouldn't the recycle 
+        // function do that? ...CHECK/TODO/FIXME
+
+        col[r] = fn(
+          left_values[c][r] || { type: ValueType.undefined }, 
+          right_values[c][r] || { type: ValueType.undefined });
+        
       }
       value.push(col);
     }

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

@@ -88,6 +88,98 @@ const inverse_normal = (q: number): number => {
 
 };
 
+const zlookup_arguments = [
+  {
+    name: "Lookup value",
+  },
+  {
+    name: "Table",
+  },
+  {
+    name: "Result index",
+  },
+  {
+    name: "Inexact",
+    default: true,
+  },
+];
+
+/**
+ * unified VLOOKUP/HLOOKUP. ordinarily we'd call it XLOOKUP but that's taken.
+ * FIXME: can't use use that function for this? 
+ */
+const ZLookup = (value: any, table: any[][], col: number, inexact = true, transpose = false): UnionValue => {
+
+  if (transpose) {
+    table = Utils.TransposeArray(table);
+  }
+
+  col = Math.max(0, col - 1);
+
+  // inexact is the default. this assumes that the data is sorted,
+  // either numerically or alphabetically. it returns the closest
+  // value without going over -- meaning walk the list, and when
+  // you're over return the _previous_ item. except if there's an
+  // exact match, I guess, in that case return the exact match.
+  
+  // FIXME: there's a hint in the docs for XLOOKUP that this might
+  // be using a binary search. not sure why, but that might be 
+  // correct.
+
+  if (inexact) {
+
+    let result: any = table[col][0];
+
+    if (typeof value === 'number') {
+
+      let compare = Number(table[0][0]);
+      if (isNaN(compare) || compare > value) {
+        return NAError();
+      }
+
+      for (let i = 1; i < table[0].length; i++) {
+        compare = Number(table[0][i]);
+        if (isNaN(compare) || compare > value) {
+          break;
+        }
+        result = table[col][i];
+
+      }
+
+    }
+    else {
+
+      value = value.toLowerCase(); // ?
+      let compare: string = (table[0][0] || '').toString().toLowerCase();
+      if (compare.localeCompare(value) > 0) {
+        return NAError();
+      }
+
+      for (let i = 1; i < table[0].length; i++) {
+        compare = (table[0][i] || '').toString().toLowerCase();
+        if (compare.localeCompare(value) > 0) {
+          break;
+        }
+        result = table[col][i];
+
+      }
+
+    }
+
+    return Box(result);
+
+  }
+  else {
+    for (let i = 0; i < table[0].length; i++) {
+      if (table[0][i] == value) { // ==
+        return Box(table[col][i]);
+      }
+    }
+    return NAError();
+  }
+
+};
+
 /**
  * alternate functions. these are used (atm) only for changing complex 
  * behavior.
@@ -637,6 +729,77 @@ export const BaseFunctionLibrary: FunctionMap = {
       })
     },
 
+    Large: {
+      description: 'Returns the nth numeric value from the data, in descending order',
+      arguments: [
+        {
+          name: 'values',
+        }, 
+        {
+          name: 'index',
+        }
+      ],
+
+      // OK a little tricky here -- we're going to reverse the arguments
+      // so we can call apply as array, but applying against the trailing
+      // arguments.
+
+      fn: Utils.ApplyAsArraySwap((data: any, index: number) => {
+
+        if (index <= 0) {
+          return ArgumentError();
+        }
+
+        const flat = Utils.FlattenUnboxed(data);
+        const numeric: number[] = flat.filter(test => typeof test === 'number');
+        numeric.sort((a, b) => b - a);
+
+        if (index <= numeric.length) {
+          return {
+            type: ValueType.number,
+            value: numeric[index - 1],
+          };
+        }
+
+        return ArgumentError();
+      }),
+    },
+
+    Small: {
+      description: 'Returns the nth numeric value from the data, in ascending order',
+      arguments: [
+        {
+          name: 'values',
+        }, 
+        {
+          name: 'index',
+        }
+      ],
+
+      // see large, above
+
+      fn: Utils.ApplyAsArraySwap((data: any, index: number) => {
+
+        if (index <= 0) {
+          return ArgumentError();
+        }
+
+        const flat = Utils.FlattenUnboxed(data);
+        const numeric: number[] = flat.filter(test => typeof test === 'number');
+        numeric.sort((a, b) => a - b);
+
+        if (index <= numeric.length) {
+          return {
+            type: ValueType.number,
+            value: numeric[index - 1],
+          };
+        }
+
+        return ArgumentError();
+
+      }),
+    },
+
     /**
      * sort arguments, but ensure we return empty strings to
      * fill up the result array
@@ -803,90 +966,275 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
     */
    
-    /**
-     * FIXME: does not implement inexact matching (what's the algo for
-     * that, anyway? nearest? price is right style? what about ties?)
+    /*
+     * unsaid anywhere (that I can locate) aboud XLOOKUP is that lookup 
+     * array must be one-dimensional. it can be either a row or a column,
+     * but one dimension must be one. that simplifies things quite a bit.
+     * 
+     * there's a note in the docs about binary search over the data -- 
+     * that might explain how inexact VLOOKUP works as well. seems an odd
+     * choice but maybe back in the day it made sense
      */
-    VLookup: {
-
+    XLOOKUP: {
       arguments: [
-        {
-          name: "Lookup value",
-        },
-        {
-          name: "Table",
-        },
-        {
-          name: "Result index",
-        },
-        {
-          name: "Inexact",
-          default: true,
-        },
+        { name: 'Lookup value', },
+        { name: 'Lookup array',  },
+        { name: 'Return array',  },
+        { name: 'Not found', boxed: true },
+        { name: 'Match mode', default: 0, },
+        { name: 'Search mode', default: 1, },
       ],
+      xlfn: true,
+      fn: (
+          lookup_value: any, 
+          lookup_array: any[][], 
+          return_array: any[][],
+          not_found?: UnionValue,
+          match_mode = 0,
+          search_mode = 1,
+          ): UnionValue => {
+
+        // FIXME: we could I suppose be more graceful about single values
+        // if passed instead of arrays
+        
+        if (!Array.isArray(lookup_array)) {
+          console.info("lookup is not an array");
+          return ValueError();
+        }
 
-      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+        const first = lookup_array[0];
+        if (!Array.isArray(first)) {
+          console.info("lookip is not a 2d array");
+          return ValueError();
+        }
 
-        col = Math.max(0, col - 1);
+        if (lookup_array.length !== 1 && first.length !== 1) {
+          console.info("lookup array has invalid dimensions");
+          return ValueError();
+        }
 
-        // inexact is the default. this assumes that the data is sorted,
-        // either numerically or alphabetically. it returns the closest
-        // value without going over -- meaning walk the list, and when
-        // you're over return the _previous_ item. except if there's an
-        // exact match, I guess, in that case return the exact match.
-        
-        if (inexact) {
+        // FIXME: is it required that the return array be (at least) the 
+        // same size? we can return undefineds, but maybe we should error
 
-          let result: any = table[col][0];
+        if (!Array.isArray(return_array)) {
+          console.info("return array is not an array");
+          return ValueError();
+        }
 
-          if (typeof value === 'number') {
+        let transpose = (lookup_array.length === 1);
+        if (transpose) {
+          lookup_array = Utils.TransposeArray(lookup_array);
+          return_array = Utils.TransposeArray(return_array);
+        }
 
-            let compare = Number(table[0][0]);
-            if (isNaN(compare) || compare > value) {
-              return NAError();
-            }
+        // maybe reverse...
+
+        if (search_mode < 0) {
+          lookup_array.reverse();
+          return_array.reverse();
+        }
 
-            for (let i = 1; i < table[0].length; i++) {
-              compare = Number(table[0][i]);
-              if (isNaN(compare) || compare > value) {
-                break;
+        //
+        // return value at index, transpose if necessary, and return
+        // an array. we might prefer to return a scalar if there's only 
+        // one value, not sure what's the intended behavior
+        // 
+        const ReturnIndex = (index: number): UnionValue => {
+
+          const values = return_array[index];
+
+          if (!values) {
+            return { type: ValueType.undefined };
+          }
+          
+          if (!Array.isArray(values)) {
+            return Box(values);
+          }
+
+          let boxes = [values.map(value => Box(value))];
+          
+          if (transpose) {
+            boxes = Utils.TransposeArray(boxes);
+          }
+
+          return {
+            type: ValueType.array,
+            value: boxes,
+          }
+
+        };
+      
+        // if value is not a string, then we can ignore wildcards.
+        // in that case convert to exact match.
+
+        if (match_mode === 2 && typeof lookup_value !== 'string') {
+          match_mode = 0;
+        }
+
+        // what does inexact matching mean in this case if the lookup
+        // value is a string or boolean? (...)
+
+        if ((match_mode === 1 || match_mode === -1) && typeof lookup_value === 'number') {
+
+          let min_delta = 0;
+          let index = -1;
+
+          for (let i = 0; i < lookup_array.length; i++) {
+            const value = lookup_array[i][0];
+           
+
+            if (typeof value === 'number') {
+
+              // check for exact match first, just in case
+              if (value === lookup_value) {
+                return ReturnIndex(i); 
+              }
+
+              const delta = Math.abs(value - lookup_value);
+
+              if ((match_mode === 1 && value > lookup_value) || (match_mode === -1 && value < lookup_value)){
+                if (index < 0 || delta < min_delta) {
+                  min_delta = delta;
+                  index = i;
+                }
               }
-              result = table[col][i];
 
             }
+          }
 
+          if (index >= 0) {
+            return ReturnIndex(index);
           }
-          else {
 
-            value = value.toLowerCase(); // ?
-            let compare: string = (table[0][0] || '').toString().toLowerCase();
-            if (compare.localeCompare(value) > 0) {
-              return NAError();
-            }
+        }
+        
+        switch (match_mode) {
+
+          case 2:
+            {
+              // wildcard string match. we only handle strings for 
+              // this case (see above).
 
-            for (let i = 1; i < table[0].length; i++) {
-              compare = (table[0][i] || '').toString().toLowerCase();
-              if (compare.localeCompare(value) > 0) {
-                break;
+              const pattern = Utils.ParseWildcards(lookup_value);
+              const regex = new RegExp('^' + pattern + '$', 'i'); //.exec(lookup_value);
+
+              for (let i = 0; i < lookup_array.length; i++) {
+                let value = lookup_array[i][0];
+                if (typeof value === 'string' && regex.exec(value)) {
+                  return ReturnIndex(i);
+                }
               }
-              result = table[col][i];
 
             }
+            break;
 
-          }
+          case 0:
+            if (typeof lookup_value === 'string') {
+              lookup_value = lookup_value.toLowerCase();
+            }
+            for (let i = 0; i < lookup_array.length; i++) {
+              let value = lookup_array[i][0];
+ 
+              if (typeof value === 'string') {
+                value = value.toLowerCase();
+              }
+              if (value === lookup_value) {
+                return ReturnIndex(i);
+              }
+            }
 
-          return Box(result);
+            break;
+        }
+
+        /*
+        const flat_lookup = Utils.FlattenUnboxed(lookup_array);
+        const flat_return = Utils.FlattenUnboxed(return_array);
 
+        // maybe reverse... 
+
+        if (search_mode < 0) {
+          flat_lookup.reverse();
+          flat_return.reverse();
         }
-        else {
-          for (let i = 0; i < table[0].length; i++) {
-            if (table[0][i] == value) { // ==
-              return Box(table[col][i]);
+
+        // if value is not a string, then we can ignore wildcards.
+        // in that case convert to exact match.
+
+        if (match_mode === 2 && typeof lookup_value !== 'string') {
+          match_mode = 0;
+        }
+
+        switch (match_mode) {
+          case 2:
+
+            {
+
+              // wildcard string match. we only handle strings
+              // for wildcard matching (handled above).
+
+              const pattern = Utils.ParseWildcards(lookup_value);
+              const regex = new RegExp('^' + pattern + '$', 'i'); //.exec(lookup_value);
+
+              for (let i = 0; i < flat_lookup.length; i++) {
+                let value = flat_lookup[i];
+                if (typeof value === 'string' && regex.exec(value)) {
+                  return Box(flat_return[i]);
+                }
+              }
+ 
+
             }
-          }
-          return NAError();
+
+            break;
+
+          case 0: 
+          
+            // return exact match or NA/default. in this case
+            // "exact" means icase (but not wildcard)
+
+            if (typeof lookup_value === 'string') {
+              lookup_value = lookup_value.toLowerCase();
+            }
+            for (let i = 0; i < flat_lookup.length; i++) {
+              let value = flat_lookup[i];
+              if (typeof value === 'string') {
+                value = value.toLowerCase();
+              }
+              if (value === lookup_value) {
+                return Box(flat_return[i]);
+              }
+            }
+
+            break;
         }
+        */
+
+        // FIXME: if we're expecting to return an array maybe we should
+        // pack it up as an array? if it's not already an array? (...)
+
+        return (not_found && not_found.type !== ValueType.undefined) ? not_found : NAError();
+
+      },
+    },
 
+    /**
+     * copied from HLOOKUP, fix that one first
+     */
+    HLookup: {
+      arguments: [...zlookup_arguments],
+      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+        return ZLookup(value, table, col, inexact, true);
+      },
+    },
+
+    /**
+     * FIXME: does not implement inexact matching (what's the algo for
+     * that, anyway? nearest? price is right style? what about ties?)
+     */
+    VLookup: {
+      arguments: [...zlookup_arguments],
+      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+        return ZLookup(value, table, col, inexact, false);
       },
     },
 

package/treb-calculator/src/utilities.ts

@@ -193,22 +193,52 @@ export const ApplyArrayFunc = (base: (...args: any[]) => any) => {
   };
 };
 
+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);
+
+        })),
+      };
+      
+    }
+    else {
+      return base(...rest, a);
+    }
+  }
+};
+
 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);
         })),
       };
-
-      /*
-      return a.map(row => row.map((element: any) => {
-        return base(element, ...rest);
-      }));
-      */
     }
     else if (typeof a === 'object' && !!a && a.type === ValueType.array ) {
       return {
@@ -280,23 +310,6 @@ export const ApplyAsArray2 = (base: (a: any, b: any, ...rest: any[]) => UnionVal
       };
     }
 
-    /*
-    if (Array.isArray(a)) {
-      if (Array.isArray(b)) {
-        return a.map((row, i: number) => row.map((element: any, j: number) => {
-          return base(element, b[i][j], ...rest);
-        }));
-      }
-      else {
-        return a.map(row => row.map((element: any) => {
-          return base(element, b, ...rest);
-        }));
-      }
-    }
-    else {
-      return base(a, b, ...rest);
-    }
-    */
     return base(a, b, ...rest);
 
   }