@trebco/treb 28.11.1 → 28.13.2

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v28.11. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v28.13. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map
@@ -756,6 +756,9 @@ export declare class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     /**
      * Create a macro function.
      *
+     * FIXME: this needs a control for argument separator, like other
+     * functions that use formulas (@see SetRange)
+     *
      * @public
      */
     DefineFunction(name: string, argument_names?: string | string[], function_def?: string): void;
@@ -1105,6 +1108,11 @@ export interface SerializeOptions {
 
     /** share resources (images, for now) to prevent writing data URIs more than once */
     share_resources?: boolean;
+
+    /**
+     * if a function has an export() handler, call that
+     */
+    export_functions?: boolean;
 }
 
 /**

package/package.json

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

package/treb-calculator/src/calculator.ts

@@ -23,7 +23,7 @@ import type { Cell, ICellAddress, ICellAddress2, UnionValue, EvaluateOptions,
          ArrayUnion, IArea, CellDataWithAddress, CellValue} from 'treb-base-types';
 import { Localization, Area, ValueType, IsCellAddress} from 'treb-base-types';
          
-import type { ExpressionUnit, DependencyList, UnitRange, UnitAddress, UnitIdentifier } from 'treb-parser';
+import type { ExpressionUnit, DependencyList, UnitRange, UnitAddress, UnitIdentifier, ParseResult } from 'treb-parser';
 import { Parser,
          DecimalMarkType, ArgumentSeparatorType, QuotedSheetNameRegex } from 'treb-parser';
 
@@ -57,6 +57,8 @@ import { StateLeafVertex } from './dag/state_leaf_vertex';
 import { CalculationLeafVertex } from './dag/calculation_leaf_vertex';
 import type { ConnectedElementType } from 'treb-grid';
 
+import { ValueParser } from 'treb-format';
+
 /**
  * breaking this out so we can use it for export (TODO)
  * 
@@ -241,6 +243,160 @@ export class Calculator extends Graph {
     }
 
     // special functions... need reference to the graph (this)
+    // moving countif here so we can reference it in COUNTIFS... 
+
+    const FlattenBooleans = (value: ArrayUnion) => {
+      const result: boolean[] = [];
+      for (const col of value.value) {
+        for (const entry of col) {
+          result.push(entry.type === ValueType.boolean && entry.value);
+        }
+      }
+      return result;
+    };
+
+    const CountIfInternal = (range: any, criteria: any): UnionValue => {
+
+      // do we really need parser/calculator for this? I think
+      // we've maybe gone overboard here, could we just use valueparser
+      // on the criteria and then calculate normally? I think we might...
+      // in any event there are no dynamic dependencies with this 
+      // function.
+
+      const data = Utilities.FlattenUnboxed(range);
+
+      let parse_result: ParseResult|undefined;
+      let expression: ExpressionUnit|undefined;
+
+      // we'll handle operator and operand separately
+
+      let operator = '=';
+
+      // handle wildcards first. if we have a wildcard we use a
+      // matching function so we can centralize. 
+      
+      if (typeof criteria === 'string') {
+
+        // normalize first, pull out operator
+
+        criteria = criteria.trim();
+        const match = criteria.match(/^([=<>]+)/);
+        if (match) {
+          operator = match[1];
+          criteria = criteria.substring(operator.length);
+        }
+
+        const value_parser_result = ValueParser.TryParse(criteria);
+        if (value_parser_result?.type === ValueType.string) {
+          criteria = `"${value_parser_result.value}"`;
+        }
+        else {
+          criteria = value_parser_result?.value?.toString() || '';
+        }
+
+        // console.info({operator, criteria});
+
+        // check for wildcards (this will false-positive on escaped 
+        // wildcards, which will not break but will waste cycles. we 
+        // could check. TOOD/FIXME)
+
+        if (/[?*]/.test(criteria)) {
+
+          // NOTE: we're not specifying an argument separator when writing
+          // functions, because that might break numbers passed as strings.
+          // so we write the function based on the current separator.
+
+          const separator = this.parser.argument_separator;
+
+          if (operator === '=' || operator === '<>') {
+
+            parse_result = this.parser.Parse(`=WildcardMatch({}${separator} ${criteria}${separator} ${operator === '<>'})`);
+            expression = parse_result.expression;
+
+            if (parse_result.error || !expression) {
+              return ExpressionError();
+            }
+
+            if (expression?.type === 'call' && expression.args[0]?.type === 'array') {
+              expression.args[0].values = [data];
+            }
+
+          }
+          
+        }
+
+      }
+      else {
+
+        // if it's not a string, by definition it doesn't have an 
+        // operator so use equality (default). it does not need 
+        // escaping.
+
+        criteria = (criteria || 0).toString();
+
+      }
+      
+      if (!parse_result) {
+
+        parse_result = this.parser.Parse('{}' + operator + criteria);
+        expression = parse_result.expression;
+
+        if (parse_result.error || !expression) {
+          return ExpressionError();
+        }
+        if (expression.type !== 'binary') {
+          console.warn('invalid expression [1]', expression);
+          return ExpressionError();
+        }
+        if (expression.left.type !== 'array') {
+          console.warn('invalid expression [1]', expression);
+          return ExpressionError();
+        }
+
+        // this is only going to work for binary left/right. it won't
+        // work if we change this to a function (wildcard match)
+        
+        // this will not happen anymore, we can remove
+
+        if (expression.right.type === 'identifier') {
+
+          console.warn('will never happen');
+
+          expression.right = {
+            ...expression.right,
+            type: 'literal',
+            value: expression.right.name,
+          }
+        }
+
+        expression.left.values = [data];
+
+      }
+
+      if (!expression) {
+        return ValueError();
+      }
+
+      const result = this.CalculateExpression(expression);
+      return result;
+
+      /*
+      // console.info({expression, result});
+
+      if (result.type === ValueType.array) {
+        let count = 0;
+        for (const column of (result as ArrayUnion).value) {
+          for (const cell of column) {
+            if (cell.value) { count++; }
+          }
+        }
+        return { type: ValueType.number, value: count };
+      }
+
+      return result; // error?
+      */
+
+    };
 
     this.library.Register({
 
@@ -403,6 +559,57 @@ export class Calculator extends Graph {
         },
       },
 
+      /**
+       * anything I said about COUNTIF applies here, but worse.
+       * COUNTIFS is an AND operation across separate COUNTIFs.
+       * presumably they have to be the same shape.
+       */
+      CountIfs: {
+        arguments: [
+          { name: 'range1', },
+          { name: 'criteria1', },
+          { name: 'range2', },
+          { name: 'criteria2', }
+        ],
+        fn: (...args): UnionValue => {
+
+          let count = 0;
+
+          let result = CountIfInternal(args[0], args[1]);
+          if (result.type !== ValueType.array) {
+            return result; // error
+          }
+
+          const base = FlattenBooleans(result);
+
+          for (let i = 2; i < args.length; i += 2) {
+            if (args[i] && args[i + 1]) {
+
+              const result = CountIfInternal(args[i], args[i+1]);
+              if (result.type !== ValueType.array) {
+                return result;
+              }
+
+              const step = FlattenBooleans(result);
+              for (const [index, value] of base.entries()) {
+                base[index] = value && step[index];
+              }
+              
+            }
+          }
+
+          for (const element of base) {
+            if (element) { count++; }
+          }
+          
+          return {
+            type: ValueType.number,
+            value: count,
+          }
+
+        },
+      },
+
       /**
        * this function is here so it has access to the parser.
        * this is crazy expensive. is there a way to reduce cost?
@@ -425,59 +632,7 @@ export class Calculator extends Graph {
         ],
         fn: (range, criteria): UnionValue => {
 
-          const data = Utilities.FlattenUnboxed(range);
-
-          // console.info({range, data});
-
-          // console.info({range});
-
-          if (typeof criteria !== 'string') {
-            criteria = '=' + (criteria || 0).toString();
-          }
-          else {
-            criteria = criteria.trim();
-            if (!/^[=<>]/.test(criteria)) {
-              criteria = '=' + criteria;
-            }
-          }
-
-          // switching to an array. doesn't actually seem to be any 
-          // faster... more appropriate, though.
-          
-          const parse_result = this.parser.Parse('{}' + criteria);
-          const expression = parse_result.expression;
-
-          if (parse_result.error || !expression) {
-            return ExpressionError();
-          }
-          if (expression.type !== 'binary') {
-            // console.warn('invalid expression [1]', expression);
-            return ExpressionError();
-          }
-          if (expression.left.type !== 'array') {
-            // console.warn('invalid expression [1]', expression);
-            return ExpressionError();
-          }
-
-          expression.left.values = [data];
-          const result = this.CalculateExpression(expression);
-
-          // console.info({expression, result});
-
-          // this is no longer the case because we're getting 
-          // a boxed result (union)
-
-          /*
-          if (Array.isArray(result)) {
-            let count = 0;
-            for (const column of result) {
-              for (const cell of column) {
-                if (cell.value) { count++; }
-              }
-            }
-            return { type: ValueType.number, value: count };
-          }
-          */
+          const result = CountIfInternal(range, criteria);
 
           if (result.type === ValueType.array) {
             let count = 0;
@@ -489,7 +644,7 @@ export class Calculator extends Graph {
             return { type: ValueType.number, value: count };
           }
 
-          return result; // error?
+          return result; // error
 
         },
       },
@@ -1150,12 +1305,16 @@ export class Calculator extends Graph {
     // don't assume default, always set
 
     if (Localization.decimal_separator === ',') {
-      this.parser.decimal_mark = DecimalMarkType.Comma;
-      this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
+      this.parser.SetLocaleSettings(DecimalMarkType.Comma);
+
+      // this.parser.decimal_mark = DecimalMarkType.Comma;
+      // this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
     }
     else {
-      this.parser.decimal_mark = DecimalMarkType.Period;
-      this.parser.argument_separator = ArgumentSeparatorType.Comma;
+      this.parser.SetLocaleSettings(DecimalMarkType.Period);
+
+      // this.parser.decimal_mark = DecimalMarkType.Period;
+      // this.parser.argument_separator = ArgumentSeparatorType.Comma;
     }
 
     // this.expression_calculator.UpdateLocale();
@@ -1381,17 +1540,23 @@ export class Calculator extends Graph {
   /** moved from embedded sheet */
   public Evaluate(expression: string, active_sheet?: Sheet, options: EvaluateOptions = {}, raw_result = false) {
     
-    const current = this.parser.argument_separator;
-    const r1c1_state = this.parser.flags.r1c1;
+    // const current = this.parser.argument_separator;
+    // const r1c1_state = this.parser.flags.r1c1;
+
+    this.parser.Save();
 
     if (options.argument_separator) {
       if (options.argument_separator === ',') {
-        this.parser.argument_separator = ArgumentSeparatorType.Comma;
-        this.parser.decimal_mark = DecimalMarkType.Period;
+        this.parser.SetLocaleSettings(DecimalMarkType.Period);
+
+        // this.parser.argument_separator = ArgumentSeparatorType.Comma;
+        // this.parser.decimal_mark = DecimalMarkType.Period;
       }
       else {
-        this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
-        this.parser.decimal_mark = DecimalMarkType.Comma;
+        this.parser.SetLocaleSettings(DecimalMarkType.Comma);
+
+        // this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
+        // this.parser.decimal_mark = DecimalMarkType.Comma;
       }
     }
 
@@ -1403,9 +1568,11 @@ export class Calculator extends Graph {
 
     // reset
 
-    this.parser.argument_separator = current;
-    this.parser.decimal_mark = (current === ArgumentSeparatorType.Comma) ? DecimalMarkType.Period : DecimalMarkType.Comma;
-    this.parser.flags.r1c1 = r1c1_state;
+    // this.parser.argument_separator = current;
+    // this.parser.decimal_mark = (current === ArgumentSeparatorType.Comma) ? DecimalMarkType.Period : DecimalMarkType.Comma;
+    // this.parser.flags.r1c1 = r1c1_state;
+
+    this.parser.Restore();
 
     // OK
 

package/treb-calculator/src/descriptors.ts

@@ -149,6 +149,11 @@ export interface CompositeFunctionDescriptor {
    */
   return_type?: ReturnType;
 
+  /**
+   * @internal
+   */
+  export?: (...args: any[]) => string;
+
 }
 
 export interface FunctionMap {

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

@@ -241,6 +241,51 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
   },
 
+  YearFrac: {
+    description: 'Returns the fraction of a year between two dates',
+    arguments: [
+      { name: 'Start', }, 
+      { name: 'End', },
+      { name: 'Basis', default: 0 },
+    ],
+    fn: (start: number, end: number, basis: number): UnionValue => {
+
+      // is this in the spec? should it not be negative here? (...)
+
+      if (end < start) {
+        const temp = start;
+        start = end;
+        end = temp;
+      }
+
+      const delta = Math.max(0, end - start);
+      let divisor = 360;
+
+      if (basis && basis < 0 || basis > 4) {
+        return ArgumentError();
+      }
+
+      // console.info({start, end, basis, delta});
+
+      switch (basis) {
+        case 1:
+          break;
+        case 2:
+          break;
+        case 3:
+          divisor = 365;
+          break;
+      }
+
+      return {
+        type: ValueType.number,
+        value: delta / divisor,
+      };
+
+      return NAError();
+    },
+  },
+
   Date: {
     description: 'Constructs a Lotus date from parts',
     arguments: [
@@ -299,6 +344,25 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
   },
 
+  IsNA: {
+    description: 'Checks if another cell contains a #NA error',
+    arguments: [{ name: 'reference', allow_error: true, boxed: true }],
+    fn: (...args: UnionValue[]): UnionValue => {
+
+      const values = Utils.FlattenBoxed(args);
+      for (const value of values) {
+        if (value.type === ValueType.error) {
+          if (value.value === 'N/A') {
+            return { type: ValueType.boolean, value: true };
+          }
+        }
+      }
+
+      return { type: ValueType.boolean, value: false };
+
+    },
+  },
+
   IsError: {
     description: 'Checks if another cell contains an error',
     arguments: [{ name: 'reference', allow_error: true, boxed: true }],
@@ -744,32 +808,80 @@ export const BaseFunctionLibrary: FunctionMap = {
      * that, anyway? nearest? price is right style? what about ties?)
      */
     VLookup: {
+
+      arguments: [
+        {
+          name: "Lookup value",
+        },
+        {
+          name: "Table",
+        },
+        {
+          name: "Result index",
+        },
+        {
+          name: "Inexact",
+          default: true,
+        },
+      ],
+
       fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
 
         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.
+        
         if (inexact) {
 
-          let min = Math.abs(value - table[0][0]);
           let result: any = table[col][0];
 
-          for (let i = 1; i < table[0].length; i++) {
+          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];
 
-            const abs = Math.abs(table[0][i] - value);
+            }
+
+          }
+          else {
 
-            if (abs < min) { // implies first match
-              min = abs;
+            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 = 1; i < table[0].length; i++) {
+          for (let i = 0; i < table[0].length; i++) {
             if (table[0][i] == value) { // ==
-              return table[col][i];
+              return Box(table[col][i]);
             }
           }
           return NAError();

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

@@ -26,60 +26,6 @@ import { Localization, ValueType } from 'treb-base-types';
 import * as Utils from '../utilities';
 import { ArgumentError, ValueError } from '../function-error';
 
-/**
- * parse a string with wildcards into a regex pattern
- * 
- * from
- * https://exceljet.net/glossary/wildcard
- * 
- * Excel has 3 wildcards you can use in your formulas:
- *
- * Asterisk (*) - zero or more characters
- * Question mark (?) - any one character
- * Tilde (~) - escape for literal character (~*) a literal question mark (~?), or a literal tilde (~~)
- * 
- * they're pretty liberal with escaping, nothing is an error, just roll with it
- * 
- */
-const ParseWildcards = (text: string): string => {
-
-  const result: string[] = [];
-  const length = text.length;
-
-  const escaped_chars = '[\\^$.|?*+()';
-
-  for (let i = 0; i < length; i++) {
-    let char = text[i];
-    switch (char) {
-
-      case '*':
-        result.push('.', '*');
-        break;
-
-      case '?':
-        result.push('.');
-        break;
-
-      case '~':
-        char = text[++i] || '';
-      
-      // eslint-disable-next-line no-fallthrough
-      default:
-        for (let j = 0; j < escaped_chars.length; j++) {
-          if (char === escaped_chars[j]) {
-            result.push('\\');
-            break;
-          }
-        }
-        result.push(char);
-        break;
-
-    }
-  }
-
-  return result.join('');
-
-};
 
 export const TextFunctionLibrary: FunctionMap = {
 
@@ -129,6 +75,50 @@ export const TextFunctionLibrary: FunctionMap = {
     category: ['text'],
   },
 
+  WildcardMatch: {
+    visibility: 'internal',
+    arguments: [
+      { name: 'text', },
+      { name: 'text', },
+
+      // the invert parameter is optional, defaults to false. we add this
+      // so we can invert wirhout requiring an extra function call.
+
+      { name: 'invert' }, 
+    ],
+    fn: Utils.ApplyAsArray2((a: any, b: any, invert = false) => {
+
+      if (typeof a === 'string' && typeof b === 'string') {
+        const pattern = Utils.ParseWildcards(b);
+        const match = new RegExp('^' + pattern + '$', 'i').exec(a);
+
+        return {
+          type: ValueType.boolean,
+          value: invert ? !match : !!match,
+        };
+      }
+
+      return {
+        type: ValueType.boolean,
+        value: (a === b || a?.toString() === b?.toString()),
+      }
+    }),
+  },
+
+  Exact: {
+    arguments: [
+      { name: 'text', boxed: true, },
+      { name: 'text', boxed: true, },
+    ],
+    category: ['text'],
+    fn: Utils.ApplyAsArray2((a: UnionValue, b: UnionValue): UnionValue => {
+      return {
+        type: ValueType.boolean,
+        value: (a?.value?.toString()) === (b?.value?.toString()),
+      };
+    }),
+  },
+
   Left: {
     arguments: [
       { name: 'string' },
@@ -225,7 +215,7 @@ export const TextFunctionLibrary: FunctionMap = {
         // can we get by with regexes? should we have some sort of cache
         // for common patterns?
 
-        const pattern = ParseWildcards(needle);
+        const pattern = Utils.ParseWildcards(needle);
         // console.info('n', needle, 'p', pattern);
         const match = new RegExp(pattern, 'i').exec(haystack.substr(start - 1));