@trebco/treb 30.1.8 → 30.2.10

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v30.1. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v30.2. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map
@@ -282,6 +282,17 @@ export interface EmbeddedSpreadsheetOptions {
      * starting in 30.1.0. set to false to disable.
      */
     spill?: boolean;
+
+    /**
+     * language. at the moment this controls spreadsheet function names
+     * only; the plan is to expand to the rest of the interface over time.
+     * should be an ISO 639-1 language code, like "en", "fr" or "sv" (case
+     * insensitive). we only support a limited subset of languages at the
+     * moment.
+     *
+     * leave blank or set to "locale" to use the current locale.
+     */
+    language?: string;
 }
 
 /**
@@ -393,6 +404,9 @@ export declare class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
      */
     ExternalEditor(config?: Partial<ExternalEditorConfig>): void;
 
+    /** dynamically load language module */
+    LoadLanguage(language?: string): Promise<void>;
+
     /**
      * Use this function to batch multiple document changes. Essentially the
      * grid stops broadcasting events for the duration of the function call,

package/esbuild-custom-element.mjs

@@ -5,7 +5,7 @@ import * as esbuild from 'esbuild';
 import { SassPlugin, WorkerPlugin, NotifyPlugin, HTMLPlugin } from './esbuild-utils.mjs';
 import { promises as fs } from 'fs';
 
-import pkg from './package.json' assert { type: 'json' }; 
+import pkg from './package.json' with { type: 'json' }; 
 
 
 /**
@@ -58,6 +58,26 @@ for (let i = 0; i < process.argv.length; i++) {
   }
 }
 
+/**
+ * thanks to
+ * https://github.com/evanw/esbuild/issues/3337#issuecomment-2085394950
+ */
+function RewriteIgnoredImports() {
+  return {
+    name: 'RewriteIgnoredImports',
+    setup(build) {
+      build.onEnd(async (result) => {
+        if (result.outputFiles) {
+          for (const file of result.outputFiles) {
+            const { path, text } = file;
+            await fs.writeFile(path, text.replace(/esbuild-ignore-import:/, ''));
+          }
+        }
+      });
+    },
+  };
+}
+
 /** @type esbuild.BuildOptions */
 const build_options = {
   entryPoints: [
@@ -78,7 +98,9 @@ const build_options = {
     'process.env.BUILD_VERSION': `"${pkg.version}"`,
     'process.env.BUILD_NAME': `"${pkg.name}"`,
   },
+  write: false,
   plugins: [
+    RewriteIgnoredImports(),
     NotifyPlugin(),
     WorkerPlugin(options),
     HTMLPlugin(options),

package/esbuild-utils.mjs

@@ -198,6 +198,7 @@ export const WorkerPlugin = (options) => ({
   }
 });
 
+
 /** 
  * @function
  * @param {{verbose?: boolean, minify?: boolean}} [options]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trebco/treb",
-  "version": "30.1.8",
+  "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/expression-calculator.ts

@@ -733,6 +733,41 @@ export class ExpressionCalculator {
 
   }
 
+  /**
+   * convert expr to a cell address, possibly calculating the contents.
+   * returns single address only (ranges with len > 1 will fail)
+   */
+  protected AsReference(expr: ExpressionUnit): ICellAddress|undefined {
+
+    switch (expr.type) {
+      case 'address':
+        return expr;
+
+      case 'range':
+        if (expr.start.row === expr.end.row && expr.start.column === expr.end.column) {
+          return expr.start;
+        }
+        break;
+
+      default:
+        {
+          const union = this.CalculateExpression(expr as ExtendedExpressionUnit, true);
+          if (UnionIsExpressionUnit(union)) {
+            if (union.value.type === 'address') {
+              return union.value;
+            }
+            if (union.value.type === 'range' && union.value.start.row === union.value.end.row && union.value.start.column === union.value.end.column) {
+              return union.value.start;
+            }
+          } 
+        }
+        break;
+    }
+
+    return undefined;
+
+  }
+
   protected BinaryExpression(x: UnitBinary): (expr: UnitBinary) => UnionValue /*UnionOrArray*/ {
 
     // we are constructing and caching functions for binary expressions.
@@ -758,40 +793,13 @@ export class ExpressionCalculator {
       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);
-            }
+          const start = this.AsReference(expr.left);
+          const end = this.AsReference(expr.right);
 
+          if (start && end) {
+            return this.CellFunction4(start, end);
           }
-          
+         
           return ExpressionError();
         };
       }

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 });
+