@trebco/treb 32.11.0 → 32.13.2

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v32.11. 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.11.0",
+  "version": "32.13.2",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {

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

@@ -1757,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;
@@ -1772,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(); 
         }
@@ -1848,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);
 
@@ -1953,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);
@@ -1969,7 +2026,7 @@ export const BaseFunctionLibrary: FunctionMap = {
           }
 
           if (index >= 0) {
-            return ReturnIndex(rng, index);
+            return ReturnIndex(index);
           }
 
         }
@@ -1987,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);
                 }
               }
 
@@ -2005,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 });
 
   }