@trebco/treb 32.10.0 → 32.13.2

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v32.10. Copyright 2018-2025 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v32.13. Copyright 2018-2025 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 /*
  * This file is part of TREB.
  *

package/package.json

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

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

@@ -234,6 +234,79 @@ const TrigFunction = (real: (value: number) => number, complex: (value: Complex)
   };
 }
 
+/**
+ * helper for sorting. kind of weird rules
+ */
+const SortHelper = (order: number, av: CellValue, bv: CellValue) => {
+  
+  // OK from what I can tell the rules are
+  //
+  // (1) no type coercion (but see below for blanks)
+  // (2) strings are sorted case-insensitive
+  // (3) blank values are coerced -> 0 but these are not sorted as numbers
+  // (4) order is numbers, strings, booleans, then blanks
+  //
+  // some of which makes sense, I guess...
+  // 
+  // blanks are always sorted last, irrespective of sort order. which
+  // means we can't sort and then reverse, because reverse sort is not
+  // the inverse of forward sort
+
+  // special case
+
+  if (av === bv) {
+    return 0;
+  }
+
+  // special case
+
+  if (av === undefined) {
+    return 1;
+  }
+  if (bv === undefined) {
+    return -1;
+  }
+
+  // actual comparisons
+
+  if (typeof av === 'number' && typeof bv === 'number') {
+    return (av - bv) * order;
+  }
+
+  if (typeof av === 'string' && typeof bv === 'string') {
+    return av.toLocaleLowerCase().localeCompare(bv.toLowerCase()) * order;
+  }
+
+  if (typeof av === 'boolean' && typeof bv === 'boolean') {
+    return av ? order : -order;
+  }
+
+  if (IsComplex(av) && IsComplex(bv)) {
+    return 0; // no sort order
+  }
+
+  // type rules
+
+  const types = [av, bv].map(x => {
+    switch (typeof x) {
+      case 'number':
+        return 0;
+      case 'string': 
+        return 2; 
+      case 'boolean':
+        return 3;
+      default: 
+        if (IsComplex(x)) {
+          return 1;
+        }
+        return 4;
+    }
+  });
+
+  return (types[0] - types[1]) * order;
+
+};
+
 /**
  * alternate functions. these are used (atm) only for changing complex 
  * behavior.
@@ -1176,29 +1249,149 @@ export const BaseFunctionLibrary: FunctionMap = {
 
     },
 
+    /**
+     * sortby allows multiple sort indexes, but no column sorting
+     */
+    SortBy: {
+      arguments: [
+        { name: 'array', },
+        { name: 'index', },
+        { name: 'order', description: 'Set to -1 to sort in descending order', default: 1 }
+      ],
+      fn: (ref: CellValue|CellValue[][], ...args: (CellValue|CellValue[][])[]): UnionValue => {
+
+        if (!Array.isArray(ref)) {
+          ref = [[ref]];
+        }
+
+        // must have at least one sort order? 
+
+        if (args.length < 1) {
+          return ArgumentError();
+        }
+
+        // ensure any sort argument pairs are valid... I guess they
+        // need to be the same length? what happens if not? [A: error]
+
+        const rows = ref[0]?.length || 0;
+        const orders: number[] = [];
+        const values: CellValue[][] = [];
+
+        for (let i = 0; i < args.length; i += 2) {
+          
+          const target = i/2;
+
+          let sort_range = args[i];
+          if (!Array.isArray(sort_range)) {
+            sort_range = [[sort_range]];
+          }
+
+          const check = sort_range[0]?.length || 0;
+          if (check !== rows) {
+            return ArgumentError();
+          }
+
+          let order = 1;
+          const arg = args[i+1];
+          if (typeof arg === 'number' && arg < 0) {
+            order = -1;
+          }
+
+          orders[target] = order;
+          values[target] = sort_range[0]; // (sort_range[0]).slice(0);
+          
+        }
+
+        const mapped = ref[0]?.map((value, index) => (index));
+        mapped.sort((a, b) => {
+
+          for (let i = 0; i < orders.length; i++) {
+            const order = orders[i];
+            const value_set = values[i];
+            const result = SortHelper(order, value_set[a], value_set[b]);
+            if (result) {
+              return result;
+            }
+          }
+
+          return 0;
+
+        });
+
+        // output is same shape
+
+        const columns = ref.length;
+        const result: UnionValue[][] = [];
+
+        for (let c = 0; c < columns; c++) {
+          const column: UnionValue[] = [];
+          for (const index of mapped) {
+            column.push(Box(ref[c][index]));
+          }
+          result.push(column);
+        }
+
+        return { type: ValueType.array, value: result };
+
+
+      },
+    },
+
     /**
      * sort arguments, but ensure we return empty strings to
      * fill up the result array
      * 
      * FIXME: instead of boxing all the values, why not pass them in boxed?
      * was this function just written at the wrong time?
+     * 
+     * UPDATE: rewriting to match Excel args
+     * 
      */
     Sort: {
       arguments: [
-        { name: 'values' }
+        { name: 'array', },
+        { name: 'index', },
+        { name: 'order', description: 'Set to -1 to sort in descending order', default: 1 }
       ],
-      fn: (...args: CellValue[]): UnionValue => {
+      fn: (ref: CellValue|CellValue[][], index = 1, order = 1): UnionValue => {
 
-        args = Utils.FlattenCellValues(args);
+        if (!Array.isArray(ref)) {
+          ref = [[ref]];
+        }
+
+        // FIXME: transpose for column sort
+
+        const sort_column = ref[index - 1];
+        if (!sort_column) {
+          return ArgumentError();
+        }
 
-        if(args.every(test => typeof test === 'number')) {
-          (args as number[]).sort((a, b) => a - b);
+        // clean (and be lenient)
+
+        if (order < 0) {
+          order = -1;
         }
         else {
-          args.sort(); // lexical
+          order = 1;
+        }
+        
+        const mapped = sort_column.map((value, index) => ({value, index}));
+        mapped.sort((a, b) => SortHelper(order, a.value, b.value));
+
+        // output is same shape
+
+        const columns = ref.length;
+        const result: UnionValue[][] = [];
+
+        for (let c = 0; c < columns; c++) {
+          const column: UnionValue[] = [];
+          for (const { index } of mapped) {
+            column.push(Box(ref[c][index]));
+          }
+          result.push(column);
         }
 
-        return { type: ValueType.array, value: [args.map(value => Box(value))] };
+        return { type: ValueType.array, value: result };
 
       },
     },
@@ -1564,8 +1757,10 @@ export const BaseFunctionLibrary: FunctionMap = {
         //}
 
         let rng: Area|undefined;
+        let return_from_array = false;
 
         if (return_array.type === ValueType.array) {
+
           // console.info({return_array});
 
           const arr = return_array.value;
@@ -1579,9 +1774,16 @@ export const BaseFunctionLibrary: FunctionMap = {
             rng = new Area(start.value.address, end.value.address);
           }
 
+          // we can allow a regular array here... perhaps we should 
+          // check the dimensions to ensure they match? TODO/FIXME
+
+          else {
+            return_from_array = true;
+          }
+
         }
 
-        if (!rng) {
+        if (!rng && !return_from_array) {
           console.info('invalid range');
           return ReferenceError(); 
         }
@@ -1655,7 +1857,55 @@ export const BaseFunctionLibrary: FunctionMap = {
         // an array. we might prefer to return a scalar if there's only 
         // one value, not sure what's the intended behavior
         // 
-        const ReturnIndex = (rng: Area, index: number): UnionValue => {
+        const ReturnIndex = (index: number): UnionValue => {
+
+          // FIXME: we could almost certainly merge these two paths
+
+          if (return_from_array && return_array.type === ValueType.array) {
+
+            // instead of a range, we're returning values from a static array
+
+            const src_columns = return_array.value.length;
+            const src_rows = return_array.value[0]?.length || 0;
+            const result: UnionValue[][] = [];
+
+            let start_row = 0;
+            let end_row = src_rows - 1;
+
+            let start_column = 0;
+            let end_column = src_columns - 1;
+
+            if (transpose) {
+              if (search_mode < 0) {
+                index = src_rows - 1 - index; // invert FIXME: test
+              }
+              start_row = end_row = index;
+            }
+            else {
+              if (search_mode < 0) {
+                index = src_columns - 1 - index; // invert FIXME: test
+              }
+              start_column = end_column = index;
+            }
+
+            for (let c = start_column; c <= end_column; c++) {
+              const column: UnionValue[] = [];
+              for (let r = start_row; r <= end_row; r++) {
+                column.push(return_array.value[c][r]);
+              }
+              result.push(column);
+            }
+
+            return {
+              type: ValueType.array,
+              value: result,
+            };
+            
+          }
+          
+          if (!rng) {
+            throw new Error('invalid range');
+          }
 
           // console.info("transpose?", transpose, {rng}, 'shape', rng.rows, rng.columns);
 
@@ -1760,7 +2010,7 @@ export const BaseFunctionLibrary: FunctionMap = {
 
               // check for exact match first, just in case
               if (value === lookup_value) {
-                return ReturnIndex(rng, i); 
+                return ReturnIndex(i); 
               }
 
               const delta = Math.abs(value - lookup_value);
@@ -1776,7 +2026,7 @@ export const BaseFunctionLibrary: FunctionMap = {
           }
 
           if (index >= 0) {
-            return ReturnIndex(rng, index);
+            return ReturnIndex(index);
           }
 
         }
@@ -1794,7 +2044,7 @@ export const BaseFunctionLibrary: FunctionMap = {
               for (let i = 0; i < lookup_array.length; i++) {
                 const value = lookup_array[i][0];
                 if (typeof value === 'string' && regex.exec(value)) {
-                  return ReturnIndex(rng, i);
+                  return ReturnIndex(i);
                 }
               }
 
@@ -1812,7 +2062,7 @@ export const BaseFunctionLibrary: FunctionMap = {
                 value = value.toLowerCase();
               }
               if (value === lookup_value) {
-                return ReturnIndex(rng, i);
+                return ReturnIndex(i);
               }
             }
 

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

@@ -20,9 +20,10 @@
  */
 
 import type { FunctionMap } from '../descriptors';
-import type { FunctionUnion, UnionValue} from 'treb-base-types';
-import { ValueType } from 'treb-base-types';
+import type { CellValue, FunctionUnion, UnionValue} from 'treb-base-types';
+import { Box, ValueType } from 'treb-base-types';
 import { ArgumentError, ValueError } from '../function-error';
+import { FlattenCellValues } from '../utilities';
 
 export const FPFunctionLibrary: FunctionMap = {
  
@@ -67,6 +68,195 @@ export const FPFunctionLibrary: FunctionMap = {
     },
   },
 
+  ChooseCols: {
+    description: 'Returns one or more columns from an array, by column index',
+    arguments: [{
+      name: 'array',
+    }, {
+      name: 'column',
+      repeat: true,
+    }],
+    fn: function(data: CellValue|CellValue[][], ...args: number[]) {
+
+      if (!Array.isArray(data)) {
+        data = [[data]];
+      }
+      
+      const flat = FlattenCellValues(args);
+      // console.info({flat});
+
+      const columns = data.length;
+      const result: UnionValue[][] = [];
+
+      for (let arg of flat) {
+        if (typeof arg === 'number') {
+
+          if (arg < 0) {
+            arg = columns + arg;
+          }
+          else {
+            arg--;
+          }
+
+          const col = data[arg];
+          if (col) {
+            const column: UnionValue[] = [];
+            for (const value of col) {
+              column.push(Box(value));
+            }
+            result.push(column);
+          }
+          else {
+            return ArgumentError(); // invalid column
+          }
+        }
+      }
+
+      if (!result.length) {
+        result.push([]);
+      }
+
+      return {
+        type: ValueType.array,
+        value: result,
+      };
+
+    },
+  },
+
+  ChooseRows: {
+    description: 'Returns one or more rows from an array, by row index',
+    arguments: [{
+      name: 'array',
+    }, {
+      name: 'row',
+      repeat: true,
+    }],
+    fn: function(data: CellValue|CellValue[][], ...args: number[]) {
+
+      if (!Array.isArray(data)) {
+        data = [[data]];
+      }
+      
+      const flat = FlattenCellValues(args);
+      // console.info({flat});
+
+      const rows = data[0]?.length || 0;
+      const result: UnionValue[][] = [];
+
+      for (let arg of flat) {
+        if (typeof arg === 'number') {
+
+          if (arg < 0) {
+            arg = rows + arg;
+          }
+          else {
+            arg--;
+          }
+
+          for (const [column_index, col] of data.entries()) {
+            const column = result[column_index] || [];
+            if (arg < 0 || arg >= col.length) {
+              return ArgumentError();
+            }
+            column.push(Box(col[arg]));
+            result[column_index] = column;
+          }
+
+        }
+      }
+
+      if (!result.length) {
+        result.push([]);
+      }
+
+      return {
+        type: ValueType.array,
+        value: result,
+      };
+
+    },
+  },
+
+  Take: {
+    description: 'Returns some number of rows/columns from the start or end of an array',
+    arguments: [{
+      name: 'array',
+    }, {
+      name: 'rows',
+    }, {
+      name: 'columns',
+    }],
+    fn: function(data: CellValue|CellValue[][], rows?: number, columns?: number) {
+
+      // we need one of rows, columns to be defined. neither can === 0.
+
+      if ((!rows && !columns) || rows === 0 || columns === 0 || (typeof rows !== 'number' && typeof rows !== 'undefined') || (typeof columns !== 'number' && typeof columns !== 'undefined')) {
+        return ArgumentError();
+      }
+
+      if (!Array.isArray(data)) {
+        data = [[data]];
+      }
+      
+      const data_columns = data.length;
+      const data_rows = data[0].length;
+      const result: UnionValue[][] = [];
+
+      // I guess we can compose?
+
+      // data is column-first
+
+      let start_column = 0;
+      let end_column = data_columns - 1;
+
+      let start_row = 0;
+      let end_row = data_rows - 1;
+
+      if (typeof columns === 'number') {
+
+        // clip data so it has the first (or last) X columns
+
+        if (columns > 0) {
+          end_column = Math.min(columns, data_columns) - 1;
+        }
+        else if (columns < 0) {
+          end_column = data_columns - 1;
+          start_column = Math.max(0, end_column + columns + 1);
+        }
+
+      }
+
+      if (typeof rows === 'number') {
+
+        // clip data so it has the first (or last) X columns
+
+        if (rows > 0) {
+          end_row = Math.min(rows, data_rows) - 1;
+        }
+        else if (rows < 0) {
+          end_row = data_rows - 1;
+          start_row = Math.max(0, end_row + rows + 1);
+        }
+
+      }
+
+      for (let c = start_column; c <= end_column; c++) {
+        const column: UnionValue[] = [];
+        for (let r = start_row; r <= end_row; r++) {
+          column.push(Box(data[c][r]));
+        }
+        result.push(column);
+      }
+
+      return {
+        type: ValueType.array,
+        value: result,
+      }
+
+    },
+  },
+
   Reduce: {
     description: 'Accumulates a value by applying a function to a set of values',
     arguments: [

package/treb-grid/src/types/scale-control.ts

@@ -140,11 +140,15 @@ export class ScaleControl extends EventSource<ScaleEvent> {
       }
     });
 
+    // we're overriding scroll behavior here, but it's a tiny panel.
+    // if we explicitly mark passive:false we can avoid the console
+    // warning (I think)
+
     container.addEventListener('wheel', (event: WheelEvent) => {
       event.stopPropagation();
       event.preventDefault();
       this.Tick(event.deltaY)
-    });
+    }, { passive: false });
 
   }