@trebco/treb 30.1.2 → 30.1.8

package/package.json

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

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

@@ -200,7 +200,8 @@ export class Area implements IArea {
       + (address.absolute_column ? '$' : '')
       + this.ColumnToLabel(address.column)
       + (address.absolute_row ? '$' : '')
-      + (address.row + 1);
+      + (address.row + 1)
+      + (address.spill ? '#' : '');
 
   }
 

package/treb-calculator/src/calculator.ts

@@ -36,7 +36,8 @@ import * as Utilities from './utilities';
 
 import { FunctionLibrary } from './function-library';
 import type { FunctionMap } from './descriptors';
-import { ReturnType } from './descriptors';
+// import * as Utils from './utilities';
+
 import { AltFunctionLibrary, BaseFunctionLibrary } from './functions/base-functions';
 import { FinanceFunctionLibrary } from './functions/finance-functions';
 import { TextFunctionLibrary, TextFunctionAliases } from './functions/text-functions';
@@ -666,7 +667,7 @@ export class Calculator extends Graph {
           name: 'width', },
 
         ],
-        return_type: ReturnType.reference,
+        return_type: 'reference',
         volatile: true,
         fn: ((reference: UnionValue, rows = 0, columns = 0, height?: number, width?: number): UnionValue => {
 
@@ -758,7 +759,7 @@ export class Calculator extends Graph {
         arguments: [
           { name: 'reference', description: 'Cell reference (string)' },
         ],
-        return_type: ReturnType.reference,
+        return_type: 'reference',
         volatile: true, // necessary?
         fn: ((reference: string): UnionValue => {
 

package/treb-calculator/src/descriptors.ts

@@ -23,9 +23,11 @@ import type { RenderFunction, ClickFunction, UnionValue } from 'treb-base-types'
 
 // FIXME: at least some of this could move to base types
 
+/*
 export enum ReturnType {
   value, reference
 }
+*/
 
 /**
  * descriptor for an individual argument
@@ -161,9 +163,9 @@ export interface CompositeFunctionDescriptor {
   xlfn?: boolean;
 
   /**
-   * support returning references
+   * support returning references. 'value' is default. FIXME: could just be a bool?
    */
-  return_type?: ReturnType;
+  return_type?: 'reference'|'value';
 
   /**
    * @internal

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

@@ -32,7 +32,6 @@ import type { Parser, ExpressionUnit, UnitBinary, UnitIdentifier,
          UnitGroup, UnitUnary, UnitAddress, UnitRange, UnitCall, UnitDimensionedQuantity, UnitStructuredReference } from 'treb-parser';
 import type { DataModel, MacroFunction, Sheet } from 'treb-data-model';
 import { NameError, ReferenceError, ExpressionError, UnknownError, SpillError } from './function-error';
-import { ReturnType } from './descriptors';
 
 import * as Primitives from './primitives';
 
@@ -194,7 +193,27 @@ export class ExpressionCalculator {
 
     switch (arg.type) {
     case 'address':
-      address = arg;
+
+      if (arg.spill) {
+        let sheet: Sheet|undefined;
+        if (arg.sheet_id) {
+          sheet = this.data_model.sheets.Find(arg.sheet_id);
+        }
+
+        if (!sheet) {
+          console.error('missing sheet [da6]');
+          return ReferenceError();
+        }
+
+        const cell_data = sheet.CellData(arg);
+        if (cell_data.spill) {
+          range = cell_data.spill;
+        }
+        
+      }
+      else {
+        address = arg;
+      }
       break;
 
     case 'range':
@@ -541,7 +560,7 @@ export class ExpressionCalculator {
         return argument_error;
       }
 
-      if (func.return_type === ReturnType.reference) {
+      if (func.return_type === 'reference') {
 
         const result = func.fn.apply(null, mapped_args);
         
@@ -731,6 +750,52 @@ export class ExpressionCalculator {
     const fn = Primitives.MapOperator(x.operator);
 
     if (!fn) {
+
+      // support dynamically-constructed ranges, as long as the 
+      // arguments are both addresses (we might see ranges, but
+      // if they are 1x1 then we can accept them)
+
+      if (x.operator === ':') {
+        return (expr: UnitBinary) => {
+
+          const left = this.CalculateExpression(expr.left as ExtendedExpressionUnit, true);
+          const right = this.CalculateExpression(expr.right as ExtendedExpressionUnit, true);
+  
+          let start: UnitAddress|undefined;
+          let end: UnitAddress|undefined;
+
+          // console.info({expr, left, right});
+
+          if (UnionIsExpressionUnit(left) && UnionIsExpressionUnit(right)) {
+
+            if (left.value.type === 'range') {
+              if (left.value.start.row === left.value.end.row && left.value.start.column === left.value.end.column) {
+                start = left.value.start;
+              }
+            }
+            else if (left.value.type === 'address') {
+              start = left.value;
+            }
+
+            if (right.value.type === 'range') {
+              if (right.value.start.row === right.value.end.row && right.value.start.column === right.value.end.column) {
+                end = right.value.start;
+              }
+            }
+            else if (right.value.type === 'address') {
+              end = right.value;
+            }
+
+            if (start && end) {
+              return this.CellFunction4(start, end);
+            }
+
+          }
+          
+          return ExpressionError();
+        };
+      }
+
       return () => { // expr: UnitBinary) => {
         console.info(`(unexpected binary operator: ${x.operator})`);
         return ExpressionError();

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

@@ -24,7 +24,7 @@ import * as Utils from '../utilities';
 import { ReferenceError, NotImplError, NAError, ArgumentError, DivideByZeroError, ValueError } from '../function-error';
 import type { UnionValue, 
          RenderFunctionResult, RenderFunctionOptions, Complex, CellValue } from 'treb-base-types';
-import { Box, ValueType, GetValueType, ComplexOrReal, IsComplex } from 'treb-base-types';
+import { Box, ValueType, GetValueType, ComplexOrReal, IsComplex, Area } from 'treb-base-types';
 import { Sparkline } from './sparkline';
 import { LotusDate, UnlotusDate } from 'treb-format';
 
@@ -33,6 +33,7 @@ import { UnionIsMetadata } from '../expression-calculator';
 
 import { Exp as ComplexExp, Power as ComplexPower, Multiply as ComplexMultply } from '../complex-math';
 import { CoerceComplex } from './function-utilities';
+import type { UnitAddress, UnitRange } from 'treb-parser';
 
 /**
  * BaseFunctionLibrary is a static object that has basic spreadsheet
@@ -1180,7 +1181,11 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
     */
    
+
     /*
+     * rewrite of xlookup to return a reference. better compatibility.
+     * ---
+     *
      * 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.
@@ -1193,21 +1198,331 @@ export const BaseFunctionLibrary: FunctionMap = {
       arguments: [
         { name: 'Lookup value', },
         { name: 'Lookup array',  },
-        { name: 'Return array',  },
+        { name: 'Return array', metadata: true, },
+        { name: 'Not found', boxed: true },
+        { name: 'Match mode', default: 0, },
+        { name: 'Search mode', default: 1, },
+      ],
+      return_type: 'reference',
+      xlfn: true,
+      fn: (
+          lookup_value: IntrinsicValue, 
+          lookup_array: IntrinsicValue[][], 
+          return_array: UnionValue,
+          not_found?: UnionValue,
+          match_mode = 0,
+          search_mode = 1,
+          ): UnionValue => {
+
+        ////////
+
+        if (!return_array) {
+          return ArgumentError();
+        }
+
+        // const parse_result = this.parser.Parse(reference);
+        // if (parse_result.error || !parse_result.expression) {
+        //  return ReferenceError;
+        //}
+
+        let rng: Area|undefined;
+
+        if (return_array.type === ValueType.array) {
+          // console.info({return_array});
+
+          const arr = return_array.value;
+          const r = arr.length;
+          const c = arr[0].length;
+
+          const start = arr[0][0];
+          const end = arr[r-1][c-1];
+
+          if (UnionIsMetadata(start) && UnionIsMetadata(end)) {
+            rng = new Area(start.value.address, end.value.address);
+          }
+
+        }
+
+        if (!rng) {
+          console.info('invalid range');
+          return ReferenceError(); 
+        }
+        
+        // console.info({rng});
+
+        /*
+        if (return_array.type === ValueType.array) {
+
+          // subset array. this is constructed, so we can take ownership
+          // and modify it, although it would be safer to copy. also, what's
+          // the cost of functional vs imperative loops these days?
+
+          const end_row = typeof height === 'number' ? (rows + height) : undefined;
+          const end_column = typeof width === 'number' ? (columns + width) : undefined;
+
+          const result: UnionValue = {
+            type: ValueType.array,
+            value: reference.value.slice(rows, end_row).map(row => row.slice(columns, end_column)),
+          };
+
+          return result;
+
+        }
+        */
+
+        // 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();
+        }
+
+        const first = lookup_array[0];
+        if (!Array.isArray(first)) {
+          console.info("lookup is not a 2d array");
+          return ValueError();
+        }
+
+        if (lookup_array.length !== 1 && first.length !== 1) {
+          console.info("lookup array has invalid dimensions");
+          return ValueError();
+        }
+
+        // FIXME: is it required that the return array be (at least) the 
+        // same size? we can return undefineds, but maybe we should error
+
+        /*
+        if (!Array.isArray(return_array)) {
+          console.info("return array is not an array");
+          return ValueError();
+        }
+        */
+
+        const transpose = (lookup_array.length === 1);
+        if (transpose) {
+          lookup_array = Utils.TransposeArray(lookup_array);
+          // return_array = Utils.TransposeArray(return_array);
+        }
+
+        // maybe reverse...
+
+        if (search_mode < 0) {
+          lookup_array.reverse();
+          // return_array.reverse();
+        }
+
+        //
+        // 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 = (rng: Area, index: number): UnionValue => {
+
+          // console.info("transpose?", transpose, {rng}, 'shape', rng.rows, rng.columns);
+
+          let start: UnitAddress|undefined;
+          let end: UnitAddress|undefined;
+
+          // I guess "transpose" in this context means "return a row from column(s)"? rename
+
+          if (transpose) {
+         
+            if (search_mode < 0) {
+              index = rng.rows - 1 - index; // invert FIXME: test
+            }
+
+            if (index >= 0 && index < rng.rows) {
+              start = {
+                type: 'address',
+                position: 0, id: 1, label: '',
+                row: rng.start.row + index,
+                column: rng.start.column,
+                sheet_id: rng.start.sheet_id,
+              };
+
+              end = {
+                type: 'address',
+                position: 0, id: 2, label: '',
+                row: rng.start.row + index,
+                column: rng.end.column,
+                sheet_id: rng.start.sheet_id,
+              };
+            }
+
+          }
+          else {
+
+            if (search_mode < 0) {
+              index = rng.columns - 1 - index; // invert FIXME: test
+            }
+
+            if (index >= 0 && index < rng.columns) {
+              start = {
+                type: 'address',
+                position: 0, id: 1, label: '',
+                row: rng.start.row,
+                column: rng.start.column + index,
+                sheet_id: rng.start.sheet_id,
+              };
+
+              end = {
+                type: 'address',
+                position: 0, id: 2, label: '',
+                row: rng.end.row,
+                column: rng.start.column + index,
+                sheet_id: rng.start.sheet_id,
+              };
+            }
+          }
+
+          if (start && end) {
+
+            const expr: UnitRange = {
+              type: 'range',
+              position: 0,
+              id: 0,
+              label: '',
+              start, end,
+            };
+
+            // console.info({expr});
+
+            return {
+              type: ValueType.object,
+              value: expr,
+            }
+            
+          }
+
+          return { type: ValueType.undefined };
+
+        };
+      
+        // 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(rng, 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;
+                }
+              }
+
+            }
+          }
+
+          if (index >= 0) {
+            return ReturnIndex(rng, index);
+          }
+
+        }
+        
+        switch (match_mode) {
+
+          case 2:
+            {
+              // wildcard string match. we only handle strings for 
+              // this case (see above).
+
+              const pattern = Utils.ParseWildcards(lookup_value?.toString() || '');
+              const regex = new RegExp('^' + pattern + '$', 'i'); //.exec(lookup_value);
+
+              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);
+                }
+              }
+
+            }
+            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(rng, 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();
+
+      },
+    },
+
+
+    /*
+     * 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
+     * /
+    XLOOKUP: {
+      arguments: [
+        { name: 'Lookup value', },
+        { name: 'Lookup array',  },
+        { name: 'Return array', address: true, },
         { name: 'Not found', boxed: true },
         { name: 'Match mode', default: 0, },
         { name: 'Search mode', default: 1, },
       ],
+      return_type: 'reference',
       xlfn: true,
       fn: (
           lookup_value: IntrinsicValue, 
           lookup_array: IntrinsicValue[][], 
-          return_array: IntrinsicValue[][],
+          return_array: string,
           not_found?: UnionValue,
           match_mode = 0,
           search_mode = 1,
           ): UnionValue => {
 
+        console.info({return_array});
+            
+
         // FIXME: we could I suppose be more graceful about single values
         // if passed instead of arrays
         
@@ -1368,6 +1683,7 @@ export const BaseFunctionLibrary: FunctionMap = {
 
       },
     },
+    */
 
     /**
      * copied from HLOOKUP, fix that one first

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

@@ -6385,6 +6385,14 @@ export class Grid extends GridBase {
       if ((area.start.row === Infinity || area.start.row < this.active_sheet.rows) &&
         (area.start.column === Infinity || area.start.column < this.active_sheet.columns)) {
 
+          if (area.start.spill && area.end.row === area.start.row && area.end.column === area.start.column) {
+            const sheet = this.model.sheets.Find(area.start.sheet_id || -1);
+            const cell = sheet?.CellData(area.start);
+            if (cell?.spill && cell.spill.start.row === area.start.row && cell.spill.start.column === area.start.column) {
+              area.ConsumeArea(cell.spill);
+            }
+          }
+
           area = this.active_sheet.RealArea(area);
           const label = area.spreadsheet_label;