@trebco/treb 30.2.4 → 30.2.10

package/package.json

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

package/treb-calculator/src/calculator.ts

@@ -33,6 +33,7 @@ import type { CalculationResult } from './dag/spreadsheet_vertex_base';
 
 import { ExpressionCalculator, UnionIsMetadata } from './expression-calculator';
 import * as Utilities from './utilities';
+import { StringUnion } from './utilities';
 
 import { FunctionLibrary } from './function-library';
 import type { FunctionMap } from './descriptors';
@@ -567,6 +568,46 @@ export class Calculator extends Graph {
         },
       },
 
+      Address: {
+        arguments: [
+          { name: 'row' }, 
+          { name: 'column' }, 
+          { name: 'absolute' }, 
+          { name: 'a1' },
+          { name: 'sheet name'}
+        ],
+        fn: (row = 1, column = 1, absolute = 1, a1 = true, sheet_name?: string): UnionValue => {
+  
+          const address: UnitAddress = {
+            type: 'address',
+            id: 0, position: 0, label: '',
+            row: row-1, 
+            column: column-1,
+          };
+  
+          switch (absolute) {
+            case 2:
+              address.absolute_row = true;
+              break;
+            case 3:
+              address.absolute_column = true;
+              break;
+            case 4:
+              break;
+            default:
+              address.absolute_column = true;
+              address.absolute_row = true;
+          }
+  
+          if (sheet_name) {
+            address.sheet = sheet_name;
+          }
+
+          return StringUnion(this.parser.Render(address, { r1c1: !a1 }));
+  
+        },
+      },
+
       /**
        * anything I said about COUNTIF applies here, but worse.
        * COUNTIFS is an AND operation across separate COUNTIFs.

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

@@ -21,9 +21,12 @@
 
 import type { FunctionMap, IntrinsicValue } from '../descriptors';
 import * as Utils from '../utilities';
+// import { StringUnion, NumberUnion } from '../utilities';
 import { ReferenceError, NotImplError, NAError, ArgumentError, DivideByZeroError, ValueError } from '../function-error';
 import type { UnionValue, 
-         RenderFunctionResult, RenderFunctionOptions, Complex, CellValue } from 'treb-base-types';
+         RenderFunctionResult, RenderFunctionOptions, Complex, CellValue, 
+        // ICellAddress
+        } 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';
@@ -318,6 +321,15 @@ export const AltFunctionLibrary: FunctionMap = {
 
 export const BaseFunctionLibrary: FunctionMap = {
 
+  // not sure why there are functions for booleans, but there are
+  True: {
+    fn: () => ({ type: ValueType.boolean, value: true }),
+  },
+
+  False: {
+    fn: () => ({ type: ValueType.boolean, value: false }),
+  },
+
   Int: {
     fn: (value: number) => {
       return {type: ValueType.number, value: Math.floor(value) };
@@ -585,6 +597,37 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
   },
 
+  IsErr: {
+    description: 'Checks if another cell contains an 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 && value.value !== 'N/A') {
+          return { type: ValueType.boolean, value: true };
+        }
+      }
+
+      /*
+      if (Array.isArray(ref)) {
+        const values = Utils.Flatten(ref) as UnionValue[];
+        for (const value of values) {
+          if (value.type === ValueType.error) {
+            return { type: ValueType.boolean, value: true };
+          }
+        }
+      }
+      else if (ref) {
+        return { type: ValueType.boolean, value: ref.type === ValueType.error };
+      }
+      */
+
+      return { type: ValueType.boolean, value: false };
+
+    },
+  },
+
   IsError: {
     description: 'Checks if another cell contains an error',
     arguments: [{ name: 'reference', allow_error: true, boxed: true }],
@@ -1182,6 +1225,126 @@ export const BaseFunctionLibrary: FunctionMap = {
     */
    
 
+    Row: {
+      arguments: [{ name: 'reference', metadata: true }],
+      fn: (ref: UnionValue): UnionValue => {
+        if (ref.type === ValueType.array) {
+          const arr = ref.value;
+          const first = arr[0][0];
+
+          if (UnionIsMetadata(first)) {
+            return {
+              type: ValueType.array,
+              value: [arr[0].map((row, index) => ({
+                type: ValueType.number,
+                value: index + first.value.address.row + 1
+              }))],
+            };
+          }
+
+        }
+        else if (UnionIsMetadata(ref)) {
+          return {
+            type: ValueType.number, value: ref.value.address.row + 1,
+          }
+        }
+        return ArgumentError();
+      },
+    },
+
+    Column: {
+      arguments: [{ name: 'reference', metadata: true }],
+      fn: (ref: UnionValue): UnionValue => {
+        if (ref.type === ValueType.array) {
+          const arr = ref.value;
+          const first = arr[0][0];
+
+          if (UnionIsMetadata(first)) {
+            return {
+              type: ValueType.array,
+              value: arr.map((row, index) => [{
+                type: ValueType.number,
+                value: index + first.value.address.column + 1
+              }]),
+            };
+          }
+
+        }
+        else if (UnionIsMetadata(ref)) {
+          return {
+            type: ValueType.number, value: ref.value.address.row + 1,
+          }
+        }
+        return ArgumentError();
+      },
+    },
+    
+    Choose: {
+      arguments: [
+        { name: 'Selected index', },
+        { name: 'Choice 1...', metadata: true },
+      ],
+      return_type: 'reference',
+      description: 'Returns one of a list of choices',
+      fn: (selected: number, ...choices: UnionValue[]): UnionValue => {
+
+        if (selected < 1 || selected > choices.length) {
+          return ValueError();
+        }
+
+        const value = choices[selected - 1];
+
+        // this should be metadata. is there a different object we 
+        // might run into? maybe we should refactor how metadata works
+
+        if (UnionIsMetadata(value)) {
+          return {
+            type: ValueType.object,
+            value: value.value.address,
+          }
+        }
+
+        // check if array is metadata. if it's a literal array
+        // we just want to return it.
+
+        if (value.type === ValueType.array) {
+          const arr = value.value;
+          const rows = arr.length;
+          const cols = arr[0].length;
+          const first = arr[0][0];
+          const last = arr[rows - 1][cols - 1];
+
+          if (rows === 1 && cols === 1) {
+            if (UnionIsMetadata(first)) {
+              return {
+                type: ValueType.object,
+                value: first.value.address,
+              };
+            }
+          }
+          else {
+            if (UnionIsMetadata(first) && UnionIsMetadata(last)) {
+              return {
+                type: ValueType.object,
+                value: {
+                  type: 'range',
+                  position: 0, id: 0, label: '',
+                  start: first.value.address,
+                  end: last.value.address,
+                }
+              }
+            }
+
+          }
+        }
+        
+        return {
+          ...value, // should we deep-copy in case of an array?
+        };
+
+      },
+    },
+
     /*
      * rewrite of xlookup to return a reference. better compatibility.
      * ---

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

@@ -260,6 +260,140 @@ export const StatisticsFunctionLibrary: FunctionMap = {
     },
   },
 
+  LCM: {
+    description: 'Retuns the least common mulitple of the arguments',
+    arguments: [{ boxed: true }],
+    fn: (...args: UnionValue[]): UnionValue => {
+      args = Utils.FlattenBoxed(args);
+      const list: number[] = [];
+
+      for (const ref of args as UnionValue[]) {
+        if (ref.type === ValueType.error) {
+          return ref;
+        }
+        if (ref.type === ValueType.number) {
+          list.push(ref.value);
+        }
+        else if (ref.type !== ValueType.undefined ) {
+          console.info("RT", ref.type);
+          return ArgumentError();
+        }
+      }
+
+      const gcd = (x: number, y: number): number => {
+        if (x % y == 0) {
+          return y;               // Base case
+        }
+        else {
+          return gcd(y, x % y);   // Recusrsive case
+        }
+      };
+
+      if (list.length === 0) {
+        return { type: ValueType.number, value: 0 };
+      }
+
+      let lcm = list[0];
+
+      for (let i = 1; i < list.length; i++) {
+        lcm = (lcm * list[i]) / gcd(lcm, list[i]);
+      }
+
+      return {
+        type: ValueType.number,
+        value: lcm,
+      }
+
+    },
+  },
+
+  GCD: {
+    description: 'Finds the greatest common divisor of the arguments',
+    arguments: [{ boxed: true }],
+    fn: (...args: UnionValue[]): UnionValue => {
+      args = Utils.FlattenBoxed(args);
+      const list: number[] = [];
+
+      for (const ref of args as UnionValue[]) {
+        if (ref.type === ValueType.error) {
+          return ref;
+        }
+        if (ref.type === ValueType.number) {
+          list.push(ref.value);
+        }
+        else if (ref.type !== ValueType.undefined ) {
+          console.info("RT", ref.type);
+          return ArgumentError();
+        }
+      }
+
+      const gcd = (x: number, y: number): number => {
+        if (x % y == 0) {
+          return y;               // Base case
+        }
+        else {
+          return gcd(y, x % y);   // Recusrsive case
+        }
+      };
+
+      if (list.length === 0) {
+        return ValueError();
+      }
+
+      if (list.length === 1) {
+        return {
+          type: ValueType.number, 
+          value: list[0],
+        };
+      }
+
+      let value = list[0];
+      for (let i = 1; i < list.length; i++) {
+        value = gcd(value, list[i]);
+      }
+      
+      return {
+        type: ValueType.number,
+        value,
+      };
+
+
+    }
+  },
+
+  HarMean: {
+    description: 'Returns the harmonic mean of the arguments',
+    arguments: [{ boxed: true }],
+    fn: (...args: UnionValue[]): UnionValue => {
+      args = Utils.FlattenBoxed(args);
+      const result = { real: 0, imaginary: 0 };
+      let count = 0;
+
+      for (const ref of args as UnionValue[]) {
+        if (ref.type === ValueType.error) {
+          return ref;
+        }
+        if (ref.type === ValueType.number) {
+          result.real += (1/ref.value);
+          count++;
+        }
+        if (ref.type === ValueType.complex) {
+          const reciprocal = ComplexMath.Divide({real: 1, imaginary: 0}, ref.value);
+          result.real += reciprocal.real;
+          result.imaginary += reciprocal.imaginary;
+          count++;
+        }
+      }
+
+      if (result.imaginary) {
+        return { type: ValueType.complex, value: ComplexMath.Divide({real: count, imaginary: 0}, result), };
+      }
+
+      return { type: ValueType.number, value: count/result.real };
+
+    },
+  },
+
   Average: {
 
     description: 'Returns the arithmetic mean of all numeric arguments',

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

@@ -120,6 +120,51 @@ export const TextFunctionLibrary: FunctionMap = {
     },
   },
 
+  Len: {
+    arguments: [
+      { name: 'string', unroll: true },
+    ],
+    fn: (str: string): UnionValue => {
+      return {
+        type: ValueType.number,
+        value: str.toString().length,
+      }
+    },
+  },
+
+  Substitute: {
+    arguments: [
+      { name: 'text' },
+      { name: 'search' },
+      { name: 'replacement' },
+      { name: 'index' },
+    ],
+    fn: (text: string, search: string, replacement: string, index?: number): UnionValue => {
+      if (typeof index === 'number') {
+        if (index < 1) {
+          return ValueError();
+        }
+      
+        let counter = 1;
+        return {
+          type: ValueType.string,
+          value: text.replaceAll(search, (...args) => {
+            console.info(args);
+            return (counter++) === index ? replacement : search;
+          }),
+        };
+
+      }
+      else {
+        return {
+          type: ValueType.string,
+          value: text.replaceAll(search, replacement),
+        };
+      }
+
+    },
+  },  
+
   Left: {
     arguments: [
       { name: 'string' },

package/treb-calculator/src/utilities.ts

@@ -352,4 +352,8 @@ export const ParseWildcards = (text: string): string => {
 
   return result.join('');
 
-};
+};
+
+export const StringUnion = (value: string): UnionValue => ({ type: ValueType.string, value });
+export const NumberUnion = (value: number): UnionValue => ({ type: ValueType.number, value });
+

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

@@ -22,12 +22,13 @@
 import type { Sheet } from './sheet';
 import { SheetCollection } from './sheet_collection';
 import { type UnitAddress, type UnitStructuredReference, type UnitRange, Parser, QuotedSheetNameRegex, DecimalMarkType, ArgumentSeparatorType } from 'treb-parser';
-import type { IArea, ICellAddress, Table, CellStyle } from 'treb-base-types';
+import type { IArea, ICellAddress, Table, CellStyle, CellValue } from 'treb-base-types';
+import { Is2DArray } from 'treb-base-types';
 import { Area, IsCellAddress, Style } from 'treb-base-types';
 import type { SerializedNamed } from './named';
 import { NamedRangeManager } from './named';
 import type { ConnectedElementType, MacroFunction } from './types';
-
+import type { LanguageModel } from './language-model';
 
 /**
  * 
@@ -36,6 +37,9 @@ export class DataModel {
 
   public readonly parser: Parser = new Parser();
 
+  /** moved from embedded spreadsheet */
+  public language_model?: LanguageModel;
+
   /** document metadata */
   public document_name?: string;
 
@@ -523,5 +527,226 @@ export class DataModel {
    */
   public connected_elements: Map<number, ConnectedElementType> = new Map();
 
+
+
+  // --- moving translation here ----------------------------------------------
+
+  
+  /** 
+   * maps common language (english) -> local language. this should 
+   * be passed in (actually set via a function).
+   */
+  private language_map?: Record<string, string>;
+
+  /**
+   * maps local language -> common (english). this should be constructed
+   * when the forward function is passed in, so there's a 1-1 correspondence.
+   */
+ private reverse_language_map?: Record<string, string>;
+
+
+  /**
+   * set the language translation map. this is a set of function names 
+   * (in english) -> the local equivalent. both should be in canonical form,
+   * as that will be used when we translate one way or the other.
+   */
+  public SetLanguageMap(language_map?: Record<string, string>) {
+
+    if (!language_map) {
+      this.language_map = this.reverse_language_map = undefined;
+    }
+    else {
+
+      const keys = Object.keys(language_map);
+
+      // normalize forward
+      this.language_map = {};
+      for (const key of keys) {
+        this.language_map[key.toUpperCase()] = language_map[key];
+      }
+
+      // normalize backward
+      this.reverse_language_map = {};
+      for (const key of keys) {
+        const value = language_map[key];
+        this.reverse_language_map[value.toUpperCase()] = key;
+      }
+
+    }
+
+    /*
+    // we might need to update the current displayed selection. depends
+    // on when we expect languages to be set.
+
+    if (!this.primary_selection.empty) {
+      this.Select(this.primary_selection, this.primary_selection.area, this.primary_selection.target);
+    }
+    */
+
+  }
+
+  /**
+   * translate function from common (english) -> local language. this could
+   * be inlined (assuming it's only called in one place), but we are breaking
+   * it out so we can develop/test/manage it.
+   */
+  public TranslateFunction(value: string): string {
+    if (this.language_map) {
+      return this.TranslateInternal(value, this.language_map, this.language_model?.boolean_true, this.language_model?.boolean_false);
+    }
+    return value;
+  }
+
+  /**
+   * translate from local language -> common (english).
+   * @see TranslateFunction
+   */
+  public UntranslateFunction(value: string): string {
+    if (this.reverse_language_map) {
+      return this.TranslateInternal(value, this.reverse_language_map, 'TRUE', 'FALSE');
+    }
+    return value;
+  }
+
+  public UntranslateData(value: CellValue|CellValue[]|CellValue[][]): CellValue|CellValue[]|CellValue[][] {
+
+    if (Array.isArray(value)) {
+
+      // could be 1d or 2d. typescript is complaining, not sure why...
+
+      if (Is2DArray(value)) {
+        return value.map(row => row.map(entry => {
+          if (entry && typeof entry === 'string' && entry[0] === '=') {
+            return this.UntranslateFunction(entry);
+          }
+          return entry;
+        }));
+      }
+      else {
+        return value.map(entry => {
+          if (entry && typeof entry === 'string' && entry[0] === '=') {
+            return this.UntranslateFunction(entry);
+          }
+          return entry;
+        });
+      }
+
+    }
+    else if (value && typeof value === 'string' && value[0] === '=') {
+
+      // single value
+      value = this.UntranslateFunction(value);
+
+    }
+
+    return value;
+
+  }
+
+
+  /**
+   * translation back and forth is the same operation, with a different 
+   * (inverted) map. although it still might be worth inlining depending
+   * on cost.
+   * 
+   * FIXME: it's about time we started using proper maps, we dropped 
+   * support for IE11 some time ago.
+   */
+  private TranslateInternal(value: string, map: Record<string, string>, boolean_true?: string, boolean_false?: string): string {
+
+    const parse_result = this.parser.Parse(value);
+
+    if (parse_result.expression) {
+      
+      let modified = false;
+      this.parser.Walk(parse_result.expression, unit => {
+        if (unit.type === 'call') {
+          const replacement = map[unit.name.toUpperCase()];
+          if (replacement) {
+            modified = true;
+            unit.name = replacement;
+          }
+        }
+        else if (unit.type === 'literal' && typeof unit.value === 'boolean') {
+
+          // to/from english/locale depends on the direction, but we're not 
+          // passing that in? FIXME, pass it as a parameter. it doesn't matter
+          // here, but later when we render.
+
+          modified = true;
+
+        } 
+
+        return true;
+      });
+
+      if (modified) {
+        return '=' + this.parser.Render(parse_result.expression, { 
+          missing: '', boolean_true, boolean_false,
+        });
+      }
+    }
+
+    return value;
+
+  }
+  
+
+  /** 
+   * this is not public _yet_ 
+   * 
+   * @internal
+   */
+  public SetLanguage(model?: LanguageModel): void {
+
+    this.language_model = model;
+
+    if (!model) {
+      this.SetLanguageMap(); // clear
+
+      // set defaults for parsing. 
+
+      this.parser.flags.boolean_true = 'TRUE';
+      this.parser.flags.boolean_false = 'FALSE';
+
+    }
+    else {
+
+      // create a name map for grid
+
+      const map: Record< string, string > = {};
+
+      if (model.functions) {
+        for (const entry of model.functions || []) {
+          map[entry.base.toUpperCase()] = entry.name; // toUpperCase because of a data error -- fix at the source
+        }
+      }
+
+      this.SetLanguageMap(map);
+
+      // console.info({map});
+
+      if (!model.boolean_false) {
+        model.boolean_false = map['FALSE'];
+      }
+      if (!model.boolean_true) {
+        model.boolean_true = map['TRUE'];
+      }
+
+      // set defaults for parsing. 
+
+      this.parser.flags.boolean_true = model.boolean_true || 'TRUE';
+      this.parser.flags.boolean_false = model.boolean_false || 'FALSE';
+
+      // console.info("booleans:", this.model.parser.flags.boolean_true, ",", this.model.parser.flags.boolean_false)
+
+    }
+
+    for (const sheet of this.sheets.list) {
+      sheet.FlushCellStyles();
+    }
+
+  }
+
 }