@trebco/treb 30.10.2 → 30.12.0

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v30.10. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v30.12. 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.10.2",
+  "version": "30.12.0",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {
@@ -12,12 +12,12 @@
   "type": "module",
   "devDependencies": {
     "@types/html-minifier": "^4.0.2",
-    "@types/node": "^22.1.0",
+    "@types/node": "^22.5.2",
     "@types/uzip": "^0.20201231.0",
     "base64-js": "^1.5.1",
     "cssnano": "^7.0.4",
-    "esbuild": "^0.23.0",
-    "eslint": "^9.8.0",
+    "esbuild": "^0.23.1",
+    "eslint": "^9.9.1",
     "fast-xml-parser": "^4.0.7",
     "html-minifier-terser": "^7.2.0",
     "sass": "^1.69.3",
@@ -31,9 +31,9 @@
     "treb-parser": "file:treb-parser",
     "treb-utils": "file:treb-utils",
     "ts-node-dev": "^2.0.0",
-    "tslib": "^2.2.0",
+    "tslib": "^2.7.0",
     "typescript": "^5.3.3",
-    "typescript-eslint": "^8.0.0",
+    "typescript-eslint": "^8.3.0",
     "uzip": "^0.20201231.0"
   },
   "scripts": {

package/treb-calculator/src/calculator.ts

@@ -55,7 +55,7 @@ import * as Primitives from './primitives';
 import type { FunctionDescriptor } from 'treb-grid';
 import type { LeafVertex } from './dag/graph';
 
-import { ArgumentError, ReferenceError, UnknownError, ValueError, ExpressionError, NAError, DivideByZeroError } from './function-error';
+import { ArgumentError, ReferenceError, UnknownError, ValueError, ExpressionError, NAError, DivideByZeroError, NotImplError } from './function-error';
 import { StateLeafVertex } from './dag/state_leaf_vertex';
 import { CalculationLeafVertex } from './dag/calculation_leaf_vertex';
 
@@ -605,6 +605,60 @@ export class Calculator extends Graph {
         },
       },
 
+      Cell: {
+        description: 'Returns data about a cell',
+        arguments: [
+          { name: 'type', description: 'Type of data to return', unroll: true,  },
+          { name: 'reference', description: 'Cell reference', metadata: true, unroll: true,  },
+        ],
+  
+        // there's no concept of "structure volatile", and structure events
+        // don't trigger recalc, so this is not helpful -- we may need to 
+        // think about both of those things
+        
+        // volatile: true, 
+  
+        fn: (type: string, reference: UnionValue): UnionValue => {
+  
+          if (!UnionIsMetadata(reference)) {
+            return ReferenceError();
+          }
+  
+          if (type) {
+            switch (type.toString().toLowerCase()) {
+              case 'format':
+                return reference.value.format ? // || ReferenceError;
+                  { type: ValueType.string, value: reference.value.format } : ReferenceError();
+              case 'address': 
+                {
+                  let sheet_name = '';
+                  if (reference.value.address.sheet_id) {
+                    const sheet = this.model.sheets.Find(reference.value.address.sheet_id);
+                    sheet_name = sheet?.name || '';
+                  }
+
+                  if (sheet_name) {
+                    if (QuotedSheetNameRegex.test(sheet_name)) {
+                      sheet_name = `'${sheet_name}'`;
+                    }
+                    sheet_name += '!';
+                  }
+
+                  return { 
+                    type: ValueType.string, 
+                    value: '[]' + sheet_name + reference.value.address.label.replace(/\$/g, ''), 
+                  };
+                }
+            }
+          }
+  
+          return { type: ValueType.error, value: NotImplError.error };
+  
+        },
+  
+      },
+  
+
       Address: {
         arguments: [
           { name: 'row' }, 
@@ -2484,7 +2538,6 @@ export class Calculator extends Graph {
 
         // first pass, run the calculation
         const check = this.Evaluate(expression, context, options, true);
-        
         entry.internal.vertex.result = check;
         entry.internal.vertex.updated = true;
 

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

@@ -22,7 +22,7 @@
 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 { ReferenceError, NAError, ArgumentError, DivideByZeroError, ValueError } from '../function-error';
 import type { UnionValue, 
          RenderFunctionResult, RenderFunctionOptions, Complex, CellValue, 
         // ICellAddress
@@ -404,7 +404,9 @@ export const BaseFunctionLibrary: FunctionMap = {
 
         switch (value.type) {
           case ValueType.number: sum.real += value.value; break;
-          case ValueType.boolean: sum.real += (value.value ? 1 : 0); break;
+          case ValueType.boolean: 
+            // sum.real += (value.value ? 1 : 0); // ??
+            break;
           case ValueType.complex:
             sum.real += value.value.real;
             sum.imaginary += value.value.imaginary;
@@ -418,6 +420,44 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
   },
 
+  SumSQ: {
+    description: 'Returns the sum of the squares of all arguments',
+    arguments: [{ boxed: true, name: 'values or ranges' }],
+    fn: (...args: UnionValue[]) => {
+
+      const sum = { real: 0, imaginary: 0 };
+      const values = Utils.FlattenBoxed(args); // as UnionValue[];
+
+      for (const value of values) {
+
+        switch (value.type) {
+          case ValueType.number: sum.real += value.value * value.value; break;
+          case ValueType.boolean: 
+            // sum.real += (value.value ? 1 : 0); // ??
+            break;
+          case ValueType.complex:
+
+            {
+              const squared = ComplexMath.Multiply(value.value, value.value);
+
+              // sum.real += value.value.real;
+              // sum.imaginary += value.value.imaginary;
+
+              sum.real += squared.real;
+              sum.imaginary += squared.imaginary;
+
+            }
+
+            break;
+          case ValueType.error: return value;
+        }
+      }
+
+      return ComplexOrReal(sum);
+
+    },
+  },
+
   // --- FIXME: break out date functions? --------------------------------------
 
   EDate: {
@@ -678,6 +718,7 @@ export const BaseFunctionLibrary: FunctionMap = {
   },
 
 
+    /*
     Cell: {
       description: 'Returns data about a cell',
       arguments: [
@@ -703,7 +744,10 @@ export const BaseFunctionLibrary: FunctionMap = {
               return reference.value.format ? // || ReferenceError;
                 { type: ValueType.string, value: reference.value.format } : ReferenceError();
             case 'address':
-              return { type: ValueType.string, value: reference.value.address.label.replace(/\$/g, '') };
+
+              // FIXME: this needs to return a fully-qualified address, we'll need access to the model
+
+              return { type: ValueType.string, value: '[]' + reference.value.address.label.replace(/\$/g, '') };
           }
         }
 
@@ -712,6 +756,7 @@ export const BaseFunctionLibrary: FunctionMap = {
       },
 
     },
+    */
 
     Year: {
       description: 'Returns year from date',
@@ -804,15 +849,31 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
 
     Not: {
-      arguments: [{ unroll: true }],
-      fn: (...args: unknown[]): UnionValue => {
-        if (args.length === 0) {
-          return ArgumentError();
-        }
-        if (args.length === 1) {
-          return Box(!args[0]);
+      arguments: [{ unroll: true, boxed: true }],
+      fn: (arg: UnionValue): UnionValue => {
+
+        let value = false;
+
+        if (arg) {
+          switch (arg.type) {
+
+          case ValueType.undefined:
+            value = false;
+            break;
+
+          case ValueType.string:
+          case ValueType.boolean:
+          case ValueType.number:
+            value = !!arg.value;
+            break;
+
+          case ValueType.error:
+            return arg;
+
+          }
         }
-        return Box(true);
+
+        return Box(!value);
       },
     },
 

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

@@ -284,12 +284,16 @@ export const TextFunctionLibrary: FunctionMap = {
       { name: 'Start', default: 1, },
     ],
     fn: (needle: string, haystack: string, start = 1): UnionValue => {
+
       if (start >= 1) {
         if (!needle) {
           return {
             type: ValueType.number, value: start,
           }
         }
+
+        needle = needle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
         const match = new RegExp(needle).exec(haystack.substr(start - 1));
         if (match) {
           return {

package/treb-calculator/src/utilities.ts

@@ -280,7 +280,9 @@ export const ApplyArrayX = <TFunc extends (...args: any[]) => UnionValue>(map: b
     let shape: unknown[][] = [];
     
     for (const [i, arg] of args.entries()) {
+
       if (arg && map[i]) {
+
         const arr = Array.isArray(arg) ? arg : IsArrayUnion(arg) ? arg.value : undefined;
         if (arr) {
           arrays[i] = arr;
@@ -298,8 +300,15 @@ export const ApplyArrayX = <TFunc extends (...args: any[]) => UnionValue>(map: b
       return {
         type: ValueType.array,
         value: shape.map((_, i) => _.map((_, j) => {
-          const apply = args.map((arg, index) => arrays[index] ? (arrays[index][i][j] || { type: ValueType.undefined }) : arg);
+
+          // this was breaking on boolean false, because 
+          // it used || instead of ??. if we don't require 
+          // boxed arguments, we need to handle naked booleans
+
+          const apply = args.map((arg, index) => arrays[index] ? (arrays[index][i][j] ?? { type: ValueType.undefined }) : arg);
+
           return base(...apply as Parameters<TFunc>);
+
         })),
       };