@trebco/treb 32.11.0 → 32.14.0

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.14. 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.14.0",
   "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);
               }
             }
 
@@ -2314,6 +2371,8 @@ export const BaseFunctionLibrary: FunctionMap = {
         unroll: true, 
       } ],
 
+      xlfn: true,
+
       fn: (a: number, significance = 1, mode?: number) => {
 
         let value = 0;

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-export/src/export.ts

@@ -1220,6 +1220,10 @@ export class Exporter {
     data = this.zip?.Get('xl/styles.xml');
     style_cache.FromXML(this.xmlparser2.parse(data || ''), theme);
 
+    // new flag: we need metadata for dynamic arrays
+
+    let dynamic_array_metadata = false;
+
     // reset counters
 
     Drawing.next_drawing_index = 1;
@@ -1573,6 +1577,7 @@ export class Exporter {
               }
               
               if (cell.area && cell.area.start.row === r && cell.area.start.column === c) {
+
                 if (typeof f === 'string') {
                   f = {
                     t$: f,
@@ -1584,6 +1589,25 @@ export class Exporter {
                 }
               }
 
+              let cm: number|undefined = undefined;
+
+              if (cell.spill && cell.spill.start.row === r && cell.spill.start.column === c) {
+
+                cm = 1;
+                dynamic_array_metadata = true;
+
+                if (typeof f === 'string') {
+                  f = {
+                    t$: f,
+                    a$: {
+                      t: 'array',
+                      ref: cell.spill.spreadsheet_label,
+                    },
+                  }
+                }
+
+              }
+
               row.push({
                 a$: {
 
@@ -1597,6 +1621,9 @@ export class Exporter {
                   // or there is no column style and it's equal to sheet style
 
                   s,
+
+                  cm,
+
                 },
 
                 f,
@@ -2357,6 +2384,83 @@ export class Exporter {
       `worksheets/sheet${index + 1}.xml`,
     ));
 
+    if (dynamic_array_metadata) {
+
+      const metadata_dom: DOMContent = {
+        metadata: {
+          a$: {
+            xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+            'xmlns:xda': 'http://schemas.microsoft.com/office/spreadsheetml/2017/dynamicarray',
+          },
+
+          metadataTypes: {
+            a$: {
+              count: 1,
+            },
+            metadataType: {
+              a$: {
+                name: 'XLDAPR',
+                minSupportedVersion: '120000',
+                copy: 1,
+                pasteAll: 1,
+                pasteValues: 1,
+                merge: 1,
+                splitFirst: 1,
+                rowColShift: 1,
+                clearFormats: 1,
+                clearComments: 1,
+                assign: 1,
+                coerce: 1,
+                cellMeta: 1,
+              },
+            },
+          },
+
+          futureMetadata: {
+            a$: {
+              name: 'XLDAPR',
+              count: 1,
+            },
+            bk: {
+              extLst: {
+                ext: {
+                  a$: {
+                    uri: '{bdbb8cdc-fa1e-496e-a857-3c3f30c029c3}',
+                  },
+                  'xda:dynamicArrayProperties': {
+                    a$: {
+                      fDynamic: 1,
+                      fCollapsed: `0`,
+                    },
+                  },
+                },
+              },
+            },
+          },
+
+          cellMetadata: {
+            a$: { count: 1 },
+            bk: {
+              rc: {
+                a$: {
+                  t: 1, 
+                  v: `0`,
+                }
+              },
+            },
+          },
+
+
+        },
+      };
+      const metadata_xml = XMLDeclaration + this.xmlbuilder1.build(metadata_dom);
+      // console.info(metadata_xml);
+      this.zip?.Set(`xl/metadata.xml`, metadata_xml);
+       
+      // add rel
+      AddRel(workbook_rels, 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sheetMetadata', 'metadata.xml');
+    }
+
     this.WriteRels(workbook_rels, `xl/_rels/workbook.xml.rels`);
 
     const definedNames: DOMContent|undefined = source.named?.length ? {
@@ -2381,8 +2485,8 @@ export class Exporter {
 
       }),
     } : undefined;
-    
-    
+   
+   
     const workbook_dom: DOMContent = {
       workbook: {
         a$: {
@@ -2487,6 +2591,11 @@ export class Exporter {
           { a$: { PartName: '/xl/styles.xml', ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml' }},
           { a$: { PartName: '/xl/sharedStrings.xml', ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml' }},
 
+          // metadata
+          ...(dynamic_array_metadata ? [
+            { a$: { PartName: '/xl/metadata.xml', ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml' }},
+          ] : []),
+
           // tables
           ...global_tables.map(table => {
             return { a$: {

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 });
 
   }