@trebco/treb 30.6.3 → 30.8.2

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v30.6. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v30.8. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map

package/package.json

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

package/treb-calculator/src/calculator.ts

@@ -2383,6 +2383,9 @@ export class Calculator extends Graph {
     // is it also (3) adding unecessary calculations (building the expression,
     // below)?
 
+    // NOTE: moving all conditional formats into EN-US (i.e. dot-separated).
+    // make sure to evaluate them in this format.
+
     if (!list) {
 
       // we could in theory remove all of the leaves (the ones we know to
@@ -2416,8 +2419,15 @@ export class Calculator extends Graph {
       let expression = '';
 
       switch (entry.type) {
+
         case 'cell-match':
-          expression = this.Unresolve(entry.area, context, true, false) + ' ' + entry.expression;
+          if (entry.between) {
+            const addr = this.Unresolve(entry.area, context, true, false);
+            expression = `BETWEEN(${[addr, ...entry.between].join(', ')})`;
+          }
+          else {
+            expression = this.Unresolve(entry.area, context, true, false) + ' ' + entry.expression;
+          }
           break;
 
         case 'expression':
@@ -2440,7 +2450,7 @@ export class Calculator extends Graph {
               entry.min ?? '',
               entry.max ?? '',
 
-            ].join(this.parser.argument_separator)
+            ].join(',')
           })`;
           break;
 
@@ -2464,13 +2474,17 @@ export class Calculator extends Graph {
 
         entry.internal.vertex = vertex;
 
-        let options: EvaluateOptions|undefined;
+        let options: EvaluateOptions = {
+          argument_separator: ',', 
+        };
+
         if (entry.type !== 'gradient' && entry.type !== 'duplicate-values') {
-          options = entry.options;
+          options = {...entry.options, ...options};
         }
 
         // first pass, run the calculation
         const check = this.Evaluate(expression, context, options, true);
+        
         entry.internal.vertex.result = check;
         entry.internal.vertex.updated = true;
 
@@ -2478,7 +2492,7 @@ export class Calculator extends Graph {
 
       const vertex = entry.internal.vertex as LeafVertex;
       this.AddLeafVertex(vertex);
-      this.UpdateLeafVertex(vertex, expression, context);
+      this.UpdateLeafVertex(vertex, expression, context, DecimalMarkType.Period); // force en-us 
 
     }
 
@@ -2846,10 +2860,15 @@ export class Calculator extends Graph {
     return dependencies;
   }
 
-  protected UpdateLeafVertex(vertex: LeafVertex, formula: string, context: Sheet): void {
+  protected UpdateLeafVertex(vertex: LeafVertex, formula: string, context: Sheet, decimal_mark?: DecimalMarkType): void {
 
     vertex.Reset();
 
+    if (decimal_mark) {
+      this.parser.Save();
+      this.parser.SetLocaleSettings(decimal_mark);
+    }
+
     const parse_result = this.parser.Parse(formula);
     if (parse_result.expression) {
       const dependencies =
@@ -2895,6 +2914,10 @@ export class Calculator extends Graph {
 
     // vertex.UpdateState();
 
+    if (decimal_mark) {
+      this.parser.Restore();
+    }
+
   }
 
   /** 

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

@@ -31,7 +31,7 @@ import { ValueType, GetValueType, Area } from 'treb-base-types';
 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 { NameError, ReferenceError, ExpressionError, UnknownError, SpillError, ValueError } from './function-error';
 
 import * as Primitives from './primitives';
 
@@ -633,7 +633,7 @@ export class ExpressionCalculator {
 
   }
 
-  protected UnaryExpression(x: UnitUnary): (expr: UnitUnary) => UnionValue /*UnionOrArray*/ { // operator: string, operand: any){
+  protected UnaryExpression(x: UnitUnary, return_reference = false): (expr: UnitUnary) => UnionValue /*UnionOrArray*/ { // operator: string, operand: any){
 
     // there are basically three code paths here: negate, identity, and error.
     // they have very different semantics so we're going to do them completely
@@ -663,6 +663,110 @@ export class ExpressionCalculator {
 
       }
 
+    case '@':
+      return (expr: UnitUnary) => {
+
+        // if the operand is a range, then we need to do implicit intersection.
+        // otherwise, calculate the expression and return the first value 
+        // if it's an array.
+
+        let address: UnitAddress|undefined;
+
+        switch (expr.operand.type) {
+          case 'address':
+            if (expr.operand.spill) {
+
+              // we need to calculate the result so we know how large the
+              // range is... perhaps there's a way to look this up without
+              // calculating? (TODO/FIXME)
+
+              const calculated = this.CellFunction2(expr.operand)();
+              if (calculated.type === ValueType.array) {
+
+                const row = this.context.address.row ?? -1;
+                const column = this.context.address.column ?? -1;
+
+                // for this verison we already have the result, so unless
+                // we're trying to preserve the address, we could just 
+                // return it
+
+                if (row >= expr.operand.row && row < expr.operand.row + calculated.value[0]?.length && calculated.value.length === 1) {
+
+                  if (!return_reference) {
+                    return calculated.value[0][row - expr.operand.row];
+                  }
+
+                  address = {
+                    ...expr.operand,
+                    row,
+                    spill: false,
+                  };
+                }
+                else if (column >= expr.operand.column && column < expr.operand.column + calculated.value.length && calculated.value[0]?.length === 1) {
+
+                  if (!return_reference) {
+                    return calculated.value[column - expr.operand.column][0];
+                  }
+
+                  address = {
+                    ...expr.operand,
+                    column,
+                    spill: false,
+                  };
+                }
+                else {
+                  return ValueError(); // out of range
+                }
+
+              }
+
+              // return { type: ValueType.string, value: 'implicit (spill)' };
+            }
+            break;
+
+          case 'range':
+            {
+              // how do we intersect, if at all?
+
+              const row = this.context.address.row ?? -1;
+              const column = this.context.address.column ?? -1;
+              if (row >= expr.operand.start.row && row <= expr.operand.end.row && expr.operand.start.column === expr.operand.end.column) {
+                address = {
+                  ...expr.operand.start,
+                  row,
+                  spill: false,
+                };
+              }
+              else if (column >= expr.operand.start.column && column <= expr.operand.end.column && expr.operand.start.row === expr.operand.end.row) {
+                address = {
+                  ...expr.operand.start,
+                  column,
+                  spill: false,
+                };
+              }
+              else {
+                return ValueError(); // out of range
+              }
+            }
+        }
+
+        if (address) {
+          if (return_reference) {
+            return { type: ValueType.object, value: address,
+            }
+          }
+          return this.CellFunction2(address)();
+       }
+
+        const operand = this.CalculateExpression(expr.operand as ExtendedExpressionUnit);
+
+        if (operand.type === ValueType.array) {
+          return operand.value[0][0];
+        }
+
+        return operand;
+      };
+
     default:
       return () => {
         console.warn('unexpected unary operator:', x.operator);
@@ -977,7 +1081,7 @@ export class ExpressionCalculator {
       return (expr.fn = this.BinaryExpression(expr))(expr); // check
 
     case 'unary':
-      return (expr.fn = this.UnaryExpression(expr))(expr); // check
+      return (expr.fn = this.UnaryExpression(expr, return_reference))(expr); // check
 
     case 'identifier':
       return (expr.fn = this.Identifier(expr))(); // check

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

@@ -244,6 +244,23 @@ const ZLookup = (value: number|string|boolean|undefined, table: (number|string|b
 
 };
 
+const NumberArgument = (argument?: UnionValue, default_value: number|false = false) => {
+
+  if (!argument) {
+    return default_value;
+  }
+
+  switch (argument.type) {
+    case ValueType.number:
+      return argument.value;
+    case ValueType.undefined:
+      return default_value;
+  }
+
+  return false;
+
+};
+
 /**
  * alternate functions. these are used (atm) only for changing complex 
  * behavior.
@@ -1923,6 +1940,17 @@ export const BaseFunctionLibrary: FunctionMap = {
       },
     },
 
+    Ceiling: {
+      arguments: [ { unroll: true }, { unroll: true } ], // FIXME: lazy
+
+      fn: (a: number) => {
+        return { 
+          type: ValueType.number, 
+          value: Math.ceil(a),
+        };
+      },
+    },
+
     Round: {
       arguments: [ { unroll: true }, { unroll: true } ], // FIXME: lazy
 
@@ -2358,6 +2386,21 @@ export const BaseFunctionLibrary: FunctionMap = {
       },
     },
 
+    Between: {
+      arguments: [
+        { name: 'target', boxed: true, unroll: true },
+        { name: 'min' },
+        { name: 'max' },
+      ],
+      visibility: 'internal',
+      fn: (target: UnionValue, min = 0, max = 1) => {
+        return {
+          type: ValueType.boolean,
+          value: (target.type === ValueType.number) && (target.value >= min && target.value <= max),
+        };
+      }
+    },
+
     Gradient: {
       arguments: [
         { name: 'range', boxed: true },
@@ -2509,7 +2552,41 @@ export const BaseFunctionLibrary: FunctionMap = {
         return ArgumentError();
 
       },
-    }
+    },
+
+    Sequence: {
+      arguments:[
+        { name: 'rows', boxed: true },
+        { name: 'columns', default: 1, boxed: true },
+        { name: 'start', default: 1, boxed: true },
+        { name: 'step', default: 1, boxed: true }
+      ],
+      fn: (rows: UnionValue, columns: UnionValue, start: UnionValue, step: UnionValue) => {
+
+        const rx = NumberArgument(rows, 1);
+        const cx = NumberArgument(columns, 1);
+        const step_ = NumberArgument(step, 1);
+        const start_ = NumberArgument(start, 1);
+
+        if (rx === false || cx === false || step_ === false || start_ === false) {
+          return ArgumentError();
+        }
+
+        const value: UnionValue[][] = [];
+        for (let c = 0; c < cx; c++) {
+          const col: UnionValue[] = [];
+          for (let r = 0; r < rx; r++) {
+            col.push({ type: ValueType.number, value: start_ + r * step_ * cx + c * step_ });
+          }
+          value.push(col);
+        }
+
+        return { type: ValueType.array, value };
+
+      },
+
+    },
+
 
 };
 

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

@@ -173,6 +173,16 @@ export class Sparkline {
       }
     }
 
+    if (min === max) {
+      if (min) {
+        min -= 1;
+        max += 1;
+      }
+      else {
+        max += 1;
+      }
+    }
+
     if (min !== max) {
 
       const step = (width * (1 - 2 * x_margin)) / (values.length - 1);
@@ -251,6 +261,16 @@ export class Sparkline {
       }
     }
 
+    if (min === max) {
+      if (min) {
+        min -= 1;
+        max += 1;
+      }
+      else {
+        max += 1;
+      }
+    }
+
     if (values.length) {
 
       // const step = (width - 2 * x_margin - 2) / (values.length-1);

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

@@ -685,6 +685,8 @@ export const StatisticsFunctionLibrary: FunctionMap = {
 export const StatisticsFunctionAliases: {[index: string]: string} = {
   Mean: 'Average',
   'StDev': 'StDev.S',
+  'StDevA': 'StDev.S',
+  'StDevPA': 'StDev.P',
   'Var': 'Var.S',
   'Quartile': 'Quartile.Inc',
 };

package/treb-data-model/src/conditional_format.ts

@@ -139,6 +139,7 @@ export interface ConditionalFormatCellMatch extends ConditionalFormatCellMatchOp
 export interface ConditionalFormatCellMatchOptions {
   style: CellStyle;
   expression: string;
+  between?: [number, number];
   options?: EvaluateOptions;
 }
 
@@ -178,8 +179,10 @@ export interface ConditionalFormatDuplicateValues extends ConditionalFormatDupli
  * 
  * ...everybody has a vertex now, we could standardize it
  * 
+ * update: adding a priority field, optional
+ * 
  */
-export type ConditionalFormat = { internal?: unknown } & (
+export type ConditionalFormat = { internal?: unknown, priority?: number } & (
     ConditionalFormatDuplicateValues |
     ConditionalFormatExpression |
     ConditionalFormatCellMatch |

package/treb-data-model/src/sheet.ts

@@ -3338,9 +3338,6 @@ export class Sheet {
     for (const format of this.conditional_formats) {
 
       if (format.internal?.vertex?.updated) {
-
-        // console.info('updated');
-
         format.internal.vertex.updated = false;
       }
 
@@ -3354,6 +3351,10 @@ export class Sheet {
       // stop rule. if you go forwards, you need some sort of indicator 
       // or flag).
 
+      // there's more to this, because there are rules that apply to areas,
+      // which might stop, and there's priority. so we probably need those
+      // flags eventually. 
+
       const area = JSON.parse(JSON.stringify(format.area));
       
       if (area.start.row === null || area.end.row === null) {

package/treb-embed/src/embedded-spreadsheet.ts

@@ -4840,6 +4840,53 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
               return reject(event.data.error || 'unknown error');
             }
 
+            if (this.parser.decimal_mark !== DecimalMarkType.Period) {
+              
+              // console.info("IMPORT WARNING 2", event.data);
+
+              // FIXME: unify w/ the convert locale method
+
+              const target_decimal_mark = this.parser.decimal_mark;
+              const target_argument_separator = this.parser.argument_separator;
+              this.parser.Save();
+              this.parser.SetLocaleSettings(DecimalMarkType.Period);
+
+              const translate = (formula: string): string | undefined => {
+                const parse_result = this.parser.Parse(formula);
+                if (!parse_result.expression) { return undefined; }
+                return '=' + this.parser.Render(
+                  parse_result.expression, { 
+                    missing: '', 
+                    convert_decimal: target_decimal_mark, 
+                    convert_argument_separator: target_argument_separator,
+                  });
+              };
+
+              for (const named of event.data.results) {
+                named.expression = translate(named.expression);                
+              }
+
+              for (const sheet of event.data.results.sheets || []) {
+
+                for (const cell of sheet.cells || []) {
+                  if (cell.type === 'formula' && cell.value) {
+                    cell.value = translate(cell.value);
+                  }
+                }
+
+                if (sheet.annotations){
+                  for (const annotation of sheet.annotations) {
+                    if (annotation.formula) {
+                      annotation.formula = translate(annotation.formula);
+                    }
+                  }
+                }
+              }
+
+              this.parser.Restore();
+
+            }
+
             this.grid.FromImportData(event.data.results);
 
             this.ResetInternal();
@@ -5914,6 +5961,15 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       }
     }
 
+    if (data.named) {
+      for (const named of data.named) {
+        const translated = translate(named.expression);
+        if (translated) {
+          named.expression = translated;
+        }
+      }
+    }
+
     if (data.sheet_data) {
 
       const sheets = Array.isArray(data.sheet_data) ? data.sheet_data : [data.sheet_data];

package/treb-export/src/import2.ts

@@ -27,10 +27,10 @@ import Base64JS from 'base64-js';
 import type { AnchoredChartDescription, AnchoredImageDescription, AnchoredTextBoxDescription} from './workbook2';
 import { ChartType, ConditionalFormatOperators, Workbook } from './workbook2';
 import type { ParseResult } from 'treb-parser';
-import { Parser } from 'treb-parser';
+import { DecimalMarkType, Parser } from 'treb-parser';
 import type { RangeType, AddressType, HyperlinkType } from './address-type';
 import { is_range, ShiftRange, InRange, is_address } from './address-type';
-import type { ImportedSheetData, AnchoredAnnotation, CellParseResult, AnnotationLayout, Corner as LayoutCorner, IArea, GradientStop, Color, HTMLColor, ThemeColor } from 'treb-base-types';
+import { type ImportedSheetData, type AnchoredAnnotation, type CellParseResult, type AnnotationLayout, type Corner as LayoutCorner, type IArea, type GradientStop, type Color, type HTMLColor, type ThemeColor, Area } from 'treb-base-types';
 import type { SerializedValueType } from 'treb-base-types';
 import type { Sheet} from './workbook-sheet2';
 import { VisibleState } from './workbook-sheet2';
@@ -341,7 +341,7 @@ export class Importer {
 
   }
 
-  public ParseConditionalFormat(address: RangeType|AddressType, rule: any): ConditionalFormat|undefined {
+  public ParseConditionalFormat(address: RangeType|AddressType, rule: any): ConditionalFormat|ConditionalFormat[]|undefined {
 
     const area = this.AddressToArea(address);
     const operators = ConditionalFormatOperators;
@@ -365,11 +365,13 @@ export class Importer {
             area,
             style,
             unique: (rule.a$.type === 'uniqueValues'),
+            priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
+
           };
         }
 
       case 'cellIs':
-        if (rule.a$.operator && rule.formula) {
+        if (rule.a$.operator && (rule.formula || typeof rule.formula === 'number')) {
           let style = {};
 
           if (rule.a$.dxfId) {
@@ -379,10 +381,26 @@ export class Importer {
             }
           }
 
+          if (rule.a$.operator === 'between') {
+            if (Array.isArray(rule.formula) && rule.formula.length === 2
+                && typeof rule.formula[0] === 'number' && typeof rule.formula[1] === 'number') {
+
+              return {
+                type: 'cell-match',
+                expression: '',
+                between: rule.formula, // special case? ugh
+                area,
+                style,
+                priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
+              };
+
+            }
+          }
+
           const operator = operators[rule.a$.operator || ''];
 
           if (!operator) {
-            console.info('unhandled cellIs operator:', rule.a$.operator);
+            console.info('unhandled cellIs operator:', rule.a$.operator, {rule});
           }
           else {
             return {
@@ -390,10 +408,14 @@ export class Importer {
               expression: operator + ' ' + rule.formula,
               area,
               style,
+              priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
             };
           }
 
         }
+        else {
+          console.info("miss?", rule);
+        }
         break;
 
       case 'containsErrors':
@@ -427,11 +449,51 @@ export class Importer {
             }
           }
 
+          if (rule.a$.type === 'expression' && (area.start.row !== area.end.row || area.start.column !== area.end.column)) {
+
+            // (1) this is only required if there are relative references
+            //     in the formula. so we could check and short-circuit.
+            //
+            // (2) I'd like to find a way to apply this as a single formula,
+            //     so there's only one rule required.
+
+            this.parser.Save();
+            this.parser.SetLocaleSettings(DecimalMarkType.Period);
+
+            const list: ConditionalFormat[] = [];
+            const a2 = new Area(area.start, area.end);
+
+            const parse_result = this.parser.Parse(rule.formula);
+            if (parse_result.expression) {
+              for (const cell of a2) {
+                const f = this.parser.Render(parse_result.expression, {
+                  missing: '',
+                  offset: { rows: cell.row - area.start.row, columns: cell.column - area.start.column }
+                });
+
+                list.push({
+                  type: 'expression',
+                  expression: f,
+                  style,
+                  area: { start: cell, end: cell },
+                  priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
+                })
+
+                // console.info(f);
+              }
+            }
+
+            this.parser.Restore();
+            return list;
+
+          }
+
           return {
             type: 'expression',
             expression: rule.formula,
             area,
             style,
+            priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
           };
 
         }
@@ -479,6 +541,8 @@ export class Importer {
             stops,
             color_space: 'RGB',
             area,
+            priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
+
           };
 
         }
@@ -545,7 +609,12 @@ export class Importer {
             for (const rule of rules) {
               const format = this.ParseConditionalFormat(area, rule);
               if (format) {
-                conditional_formats.push(format);
+                if (Array.isArray(format)) {
+                  conditional_formats.push(...format);
+                }
+                else {
+                  conditional_formats.push(format);
+                }
               }
             }
           }

package/treb-export/src/workbook2.ts

@@ -39,10 +39,15 @@ import { ZipWrapper } from './zip-wrapper';
 import type { CellStyle, ThemeColor } from 'treb-base-types';
 import type { SerializedNamed } from 'treb-data-model';
 
+/**
+ * @privateRemarks -- FIXME: not sure about the equal/equals thing. need to check.
+ */
 export const ConditionalFormatOperators: Record<string, string> = {
   greaterThan: '>',
+  greaterThanOrEqual: '>=',
   greaterThanOrEquals: '>=',
   lessThan: '<',
+  lessThanOrEqual: '<=',
   lessThanOrEquals: '<=',
   equal: '=',
   notEqual: '<>',

package/treb-grid/src/editors/editor.ts

@@ -163,7 +163,7 @@ export interface NodeDescriptor {
 
 export class Editor<E = FormulaEditorEvent> extends EventSource<E|FormulaEditorEvent> {
 
-  protected static readonly FormulaChars = ('$^&*(-+={[<>/~%' + Localization.argument_separator).split(''); // FIXME: i18n
+  protected static readonly FormulaChars = ('$^&*(-+={[<>/~%@' + Localization.argument_separator).split(''); // FIXME: i18n
 
   /**
    * the current edit cell. in the event we're editing a merged or