@trebco/treb 30.2.4 → 30.2.14

package/dist/treb.d.ts

@@ -1310,7 +1310,7 @@ export type Color = ThemeColor | HTMLColor | NullColor;
 export declare const ThemeColorIndex: (color: ThemeColor) => number;
 export declare const IsHTMLColor: (color?: Color) => color is HTMLColor;
 export declare const IsThemeColor: (color?: Color) => color is ThemeColor;
-export declare const IsDefinedColor: (color?: Color) => color is ThemeColor | HTMLColor;
+export declare const IsDefinedColor: (color?: Color) => color is (ThemeColor | HTMLColor);
 export type CellValue = undefined | string | number | boolean | Complex | DimensionedQuantity;
 
 /**

package/esbuild-custom-element.mjs

@@ -1,5 +1,7 @@
 // @ts-check
 
+/* global process */
+
 import * as esbuild from 'esbuild';
 
 import { SassPlugin, WorkerPlugin, NotifyPlugin, HTMLPlugin } from './esbuild-utils.mjs';

package/esbuild-utils.mjs

@@ -1,6 +1,8 @@
 
 // @ts-check
 
+/* global console */
+
 import * as esbuild from 'esbuild';
 import { promises as fs } from 'fs';
 import { minify } from 'html-minifier';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trebco/treb",
-  "version": "30.2.4",
+  "version": "30.2.14",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {
@@ -12,13 +12,12 @@
   "type": "module",
   "devDependencies": {
     "@types/html-minifier": "^4.0.2",
-    "@types/node": "^20.8.5",
+    "@types/node": "^22.1.0",
     "@types/uzip": "^0.20201231.0",
-    "archiver": "^6.0.1",
     "base64-js": "^1.5.1",
-    "cssnano": "^6.0.0",
-    "esbuild": "^0.20.1",
-    "eslint": "^8.56.0",
+    "cssnano": "^7.0.4",
+    "esbuild": "^0.23.0",
+    "eslint": "^9.8.0",
     "fast-xml-parser": "^4.0.7",
     "html-minifier": "^4.0.0",
     "sass": "^1.69.3",
@@ -34,7 +33,7 @@
     "ts-node-dev": "^2.0.0",
     "tslib": "^2.2.0",
     "typescript": "^5.3.3",
-    "typescript-eslint": "^7.0.2",
+    "typescript-eslint": "^8.0.0",
     "uzip": "^0.20201231.0"
   },
   "scripts": {

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

@@ -782,7 +782,36 @@ export class ExpressionCalculator {
     // unless the expression changes, which will discard the generated
     // function (along with the expression itself).
 
-    const fn = Primitives.MapOperator(x.operator);
+    // pulling out concat so we can bind the model for language values
+
+    const fn = x.operator === '&' ? (a: UnionValue, b: UnionValue): UnionValue => {
+
+      // this works, but it's not volatile so it doesn't update on 
+      // a language change; maybe language change should force a recalc? (...)
+
+      if (a.type === ValueType.error) { return a; }
+      if (b.type === ValueType.error) { return b; }
+    
+      const strings = [a, b].map(x => {
+        if (x.type === ValueType.undefined) { return ''; }
+        if (x.type === ValueType.boolean) {
+          if (x.value) {
+            return this.data_model.language_model?.boolean_true || 'TRUE';
+          }
+          else {
+            return this.data_model.language_model?.boolean_false || 'FALSE';
+          }
+        }
+        return x.value;
+      });
+
+      return {
+        type: ValueType.string, 
+        value: `${strings[0]}${strings[1]}`,
+      };
+    
+
+    } : Primitives.MapOperator(x.operator);
 
     if (!fn) {
 

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' },
@@ -256,7 +301,7 @@ export const TextFunctionLibrary: FunctionMap = {
     },
   },
 
-  /** canonical should be CONCAT; concatenate can be an alias */
+ /** canonical should be CONCAT; concatenate can be an alias */
  Concat: {
   description: 'Pastes strings together',
   fn: (...args: CellValue[]): UnionValue => {

package/treb-calculator/src/primitives.ts

@@ -266,6 +266,7 @@ export const Modulo = (a: UnionValue, b: UnionValue): UnionValue => {
   return { value: x % y, type: ValueType.number };
 };
 
+/*
 export const Concatenate = (a: UnionValue, b: UnionValue): UnionValue => {
   if (a.type === ValueType.error) { return a; }
   if (b.type === ValueType.error) { return b; }
@@ -276,6 +277,7 @@ export const Concatenate = (a: UnionValue, b: UnionValue): UnionValue => {
   };
 
 };
+*/
 
 export const Equals = (a: UnionValue, b: UnionValue): UnionValue => {
   if (a.type === ValueType.error) { return a; }
@@ -430,7 +432,7 @@ export const UseComplex = () => {
 
 export const MapOperator = (operator: string) => {
   switch(operator) {
-    case '&': return Concatenate;
+    // case '&': return Concatenate;
     case '+': return Add;
     case '-': return Subtract;
     case '*': return Multiply;

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