@trebco/treb 28.11.1 → 28.15.0

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.15. 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;
@@ -1074,7 +1077,7 @@ export interface FreezePane {
     rows: number;
     columns: number;
 }
-export type AnnotationType = 'treb-chart' | 'image' | 'external';
+export type AnnotationType = 'treb-chart' | 'image' | 'textbox' | 'external';
 export declare type BorderConstants = "none" | "all" | "outside" | "top" | "bottom" | "left" | "right";
 
 /**
@@ -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;
 }
 
 /**
@@ -1266,6 +1274,9 @@ export interface CellStyle {
     /** border color */
     border_bottom_fill?: Color;
 
+    /** text indent */
+    indent?: number;
+
     /**
      * cell is locked for editing
      */
@@ -1797,7 +1808,7 @@ export interface SerializedGridSelection {
     /** for cacheing addtional selections. optimally don't serialize */
     rendered?: boolean;
 }
-export type AnnotationData = AnnotationChartData | AnnotationImageData | AnnotationExternalData;
+export type AnnotationData = AnnotationChartData | AnnotationImageData | AnnotationExternalData | AnnotationTextBoxData;
 export interface ImageSize {
     width: number;
     height: number;
@@ -1880,6 +1891,19 @@ export interface AnnotationImageData extends AnnotationDataBase {
 export interface AnnotationChartData extends AnnotationDataBase {
     type: 'treb-chart';
 }
+export interface AnnotationTextBoxData extends AnnotationDataBase {
+    type: 'textbox';
+    data: {
+        style?: CellStyle;
+        paragraphs: {
+            style?: CellStyle;
+            content: {
+                text: string;
+                style?: CellStyle;
+            }[];
+        }[];
+    };
+}
 export interface AnnotationExternalData extends AnnotationDataBase {
     type: 'external';
     data: Record<string, string>;

package/package.json

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

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

@@ -145,6 +145,9 @@ export interface CellStyle {
   /** border color */
   border_bottom_fill?: Color;
 
+  /** text indent */
+  indent?: number;
+
   /**
    * cell is locked for editing
    * 

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/expression-calculator.ts

@@ -806,15 +806,11 @@ export class ExpressionCalculator {
 
   }
 
-  //protected ElementwiseBinaryExpression(fn: Primitives.PrimitiveBinaryExpression, left: UnionValue[][], right: UnionValue[][]): UnionValue[][] {
   protected ElementwiseBinaryExpression(fn: Primitives.PrimitiveBinaryExpression, left: ArrayUnion, right: ArrayUnion): ArrayUnion {
 
     const columns = Math.max(left.value.length, right.value.length);
     const rows = Math.max(left.value[0].length, right.value[0].length);
 
-    // const columns = Math.max(left.length, right.length);
-    // const rows = Math.max(left[0].length, right[0].length);
-
     const left_values = this.RecycleArray(left.value, columns, rows);
     const right_values = this.RecycleArray(right.value, columns, rows);
 
@@ -822,8 +818,16 @@ export class ExpressionCalculator {
 
     for (let c = 0; c < columns; c++) {
       const col: UnionValue[] = [];
+
       for (let r = 0; r < rows; r++ ) {
-        col[r] = fn(left_values[c][r], right_values[c][r]);
+
+        // handle undefineds. this is unfortunate. shouldn't the recycle 
+        // function do that? ...CHECK/TODO/FIXME
+
+        col[r] = fn(
+          left_values[c][r] || { type: ValueType.undefined }, 
+          right_values[c][r] || { type: ValueType.undefined });
+        
       }
       value.push(col);
     }