@trebco/treb 30.2.14 → 30.6.0

package/dist/treb.d.ts

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

package/{esbuild-custom-element.mjs → esbuild-composite.mjs}

@@ -4,7 +4,7 @@
 
 import * as esbuild from 'esbuild';
 
-import { SassPlugin, WorkerPlugin, NotifyPlugin, HTMLPlugin } from './esbuild-utils.mjs';
+import { SassPlugin, WorkerPlugin, NotifyPlugin, HTMLPlugin, RewriteIgnoredImports } from './esbuild-utils.mjs';
 import { promises as fs } from 'fs';
 
 import pkg from './package.json' with { type: 'json' }; 
@@ -32,7 +32,7 @@ const options = {
   minify: true, 
   verbose: false,
   xlsx_support: true,
-  output_filename: 'treb-spreadsheet.mjs',
+  output_filename: 'treb-spreadsheet',
 };
 
 //------------------------------------------------------------------------------
@@ -60,36 +60,19 @@ 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: [
-    'treb-embed/src/index.ts',
+    { in: 'treb-embed/src/index.ts', out: options.output_filename },
+    { in: 'treb-embed/src/export-worker.ts', out: 'treb-export-worker' },
   ],
   banner: { 
     js: `/*! TREB v${pkg.version}. Copyright 2018-${new Date().getFullYear()} trebco, llc. All rights reserved. LGPL: https://treb.app/license */`
   },
   bundle: true,
-  outfile: 'dist/' + options.output_filename,
+  outdir: 'dist',
+  // outfile: 'dist/' + options.output_filename,
   outExtension: { '.js': '.mjs' },
   minify: options.minify,
   metafile: true,

package/esbuild-utils.mjs

@@ -5,7 +5,7 @@
 
 import * as esbuild from 'esbuild';
 import { promises as fs } from 'fs';
-import { minify } from 'html-minifier';
+import { minify } from 'html-minifier-terser';
 import path from 'path';
 import * as sass from 'sass';
 import cssnano from 'cssnano';
@@ -116,7 +116,7 @@ export const WorkerPlugin = (options) => ({
         resolveDir: args.resolveDir,
       });
       return { path: result.path, namespace: 'worker', };
-    }),
+    });
 
     // for some reason I can't get the filter to work here, but using
     // namespace works. as long as we don't collide with anybody else.
@@ -219,10 +219,14 @@ export const HTMLPlugin = (options) => ({
       }
 
       const text = await fs.readFile(args.path, 'utf8');
+
       return {
-        contents: options?.minify ? minify(text, html_minifier_options) : text,
+        contents: options?.minify ? await minify(text, html_minifier_options) : text,
         loader: 'text',
       };
+
+
+
     });
   },
 });
@@ -282,3 +286,24 @@ export const SassPlugin = (options) => ({
     });
   },
 });
+
+/**
+ * thanks to
+ * https://github.com/evanw/esbuild/issues/3337#issuecomment-2085394950
+ */
+export const 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:/g, ''));
+          }
+        }
+      });
+    },
+  };
+};
+

package/eslint.config.js

@@ -23,7 +23,8 @@ export default tseslint.config(
 
       "@typescript-eslint/no-unused-vars": [
         "error", { 
-          "destructuredArrayIgnorePattern": "^_",
+          destructuredArrayIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
         }],
     },
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trebco/treb",
-  "version": "30.2.14",
+  "version": "30.6.0",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {
@@ -19,7 +19,7 @@
     "esbuild": "^0.23.0",
     "eslint": "^9.8.0",
     "fast-xml-parser": "^4.0.7",
-    "html-minifier": "^4.0.0",
+    "html-minifier-terser": "^7.2.0",
     "sass": "^1.69.3",
     "treb-base-types": "file:treb-base-types",
     "treb-calculator": "file:treb-calculator",
@@ -37,17 +37,16 @@
     "uzip": "^0.20201231.0"
   },
   "scripts": {
-    "build": "node esbuild-custom-element.mjs",
-    "build-light": "node esbuild-custom-element.mjs --no-xlsx --output-filename treb-spreadsheet-light.mjs",
-    "dev": "node esbuild-custom-element.mjs --dev",
+    "build": "node esbuild-composite.mjs",
+    "dev": "node esbuild-composite.mjs --dev",
     "clean": "rm -fr build dist declaration",
-    "watch": "node --watch esbuild-custom-element.mjs --watch --dev",
-    "watch-production": "node --watch esbuild-custom-element.mjs --watch",
+    "watch": "node --watch esbuild-composite.mjs --watch --dev",
+    "watch-production": "node --watch esbuild-composite.mjs --watch",
     "tsc": "tsc -b treb-embed/modern.tsconfig.json",
     "rebuild-tsc": "tsc -b --force treb-embed/modern.tsconfig.json",
     "watch-tsc": "tsc -b treb-embed/modern.tsconfig.json -w",
     "watch-api": "ts-node-dev --respawn api-generator/api-generator.ts --config api-config.json",
     "generate-api": "ts-node-dev api-generator/api-generator.ts --config api-config.json",
-    "release": "npm run rebuild-tsc && npm run build && npm run generate-api && npm run build-light"
+    "release": "npm run rebuild-tsc && npm run build && npm run generate-api"
   }
 }

package/treb-base-types/src/cells.ts

@@ -709,7 +709,7 @@ export class Cells {
                 typeof cell.calculated !== 'undefined') { // && cell.calculated_type !== ValueType.error) {
               obj.calculated = cell.calculated;
               if (cell.spill) {
-                obj.spill = cell.spill;
+                obj.spill = cell.spill.toJSON();
               }
 
               // always preserve error type, because we can't infer

package/treb-calculator/src/calculator.ts

@@ -253,6 +253,7 @@ export class Calculator extends Graph {
     // special functions... need reference to the graph (this)
     // moving countif here so we can reference it in COUNTIFS... 
 
+    /*
     const FlattenBooleans = (value: ArrayUnion) => {
       const result: boolean[] = [];
       for (const col of value.value) {
@@ -262,6 +263,58 @@ export class Calculator extends Graph {
       }
       return result;
     };
+    */
+
+    /**
+     * this is a function that does sumif/averageif/countif.
+     * args is one or more sets of [criteria_range, criteria]
+     */
+    const XIf = (type: 'sum'|'count'|'average', value_range: CellValue[][], ...args: unknown[]): UnionValue => {
+
+      const filter: boolean[] = [];
+
+      for (let i = 0; i < args.length; i += 2) {
+        if (Array.isArray(args[i])) {
+          const step = CountIfInternal(args[i] as CellValue[][], args[i+1] as CellValue);
+          if (step.type !== ValueType.array) {
+            return step;
+          }
+          for (const [r, cell] of step.value[0].entries()) {
+            filter[r] = (!!cell.value && (filter[r] !== false));
+          }
+        }
+      }
+
+      const values = Utilities.FlattenCellValues(value_range, true); // keep undefineds
+        
+      let count = 0;
+      let sum = 0;
+      for (const [index, test] of filter.entries()) {
+      if (test) {
+          count++; 
+          const value = values[index];
+          if (typeof value === 'number') {
+            sum += value;
+          }
+        }
+      }
+
+      switch (type) {
+        case 'count': 
+          return { type: ValueType.number, value: count };
+
+        case 'sum':
+          return { type: ValueType.number, value: sum };
+
+        case 'average':
+          if (count === 0) {
+            return DivideByZeroError();
+          }
+          return { type: ValueType.number, value: sum/count };
+      }
+
+
+    }
 
     const CountIfInternal = (range: CellValue[][], criteria: CellValue): UnionValue => {
 
@@ -271,7 +324,7 @@ export class Calculator extends Graph {
       // in any event there are no dynamic dependencies with this 
       // function.
 
-      const data = Utilities.FlattenCellValues(range);
+      const data = Utilities.FlattenCellValues(range, true); // keep undefineds, important for mapping
 
       let parse_result: ParseResult|undefined;
       let expression: ExpressionUnit|undefined;
@@ -326,7 +379,7 @@ export class Calculator extends Graph {
             }
 
             if (expression?.type === 'call' && expression.args[0]?.type === 'array') {
-              expression.args[0].values = [Utilities.FilterIntrinsics(data)];
+              expression.args[0].values = [Utilities.FilterIntrinsics(data, true)];
             }
 
           }
@@ -377,7 +430,7 @@ export class Calculator extends Graph {
           }
         }
 
-        expression.left.values = [Utilities.FilterIntrinsics(data)];
+        expression.left.values = [Utilities.FilterIntrinsics(data, true)];
 
       }
 
@@ -388,22 +441,6 @@ export class Calculator extends Graph {
       const result = this.CalculateExpression(expression);
       return result;
 
-      /*
-      // console.info({expression, result});
-
-      if (result.type === ValueType.array) {
-        let count = 0;
-        for (const column of (result as ArrayUnion).value) {
-          for (const cell of column) {
-            if (cell.value) { count++; }
-          }
-        }
-        return { type: ValueType.number, value: count };
-      }
-
-      return result; // error?
-      */
-
     };
 
     this.library.Register({
@@ -615,47 +652,63 @@ export class Calculator extends Graph {
        */
       CountIfs: {
         arguments: [
-          { name: 'range1', },
-          { name: 'criteria1', },
-          { name: 'range2', },
-          { name: 'criteria2', }
+          { name: 'range', },
+          { name: 'criteria', },
+          { name: 'range', },
+          { name: 'criteria', }
         ],
         fn: (...args): UnionValue => {
+          return XIf('count', args[0], ...args);
+        },
+      },
 
-          let count = 0;
-
-          const result = CountIfInternal(args[0], args[1]);
-          if (result.type !== ValueType.array) {
-            return result; // error
-          }
-
-          const base = FlattenBooleans(result);
-
-          for (let i = 2; i < args.length; i += 2) {
-            if (args[i] && args[i + 1]) {
-
-              const result = CountIfInternal(args[i], args[i+1]);
-              if (result.type !== ValueType.array) {
-                return result;
-              }
+      /** @see CountIf */
+      AverageIf: {
+        arguments: [
+          { name: 'range', },
+          { name: 'criteria', },
+        ],
+        fn: (range: CellValue[][], criteria: CellValue, average_range?: CellValue[][]) => {
+          return XIf('average', average_range||range, range, criteria);
+        },
+      },
 
-              const step = FlattenBooleans(result);
-              for (const [index, value] of base.entries()) {
-                base[index] = value && step[index];
-              }
-              
-            }
-          }
+      /** @see CountIf */
+      AverageIfs: {
+        arguments: [
+          { name: 'value range', },
+          { name: 'criteria range', },
+          { name: 'criteria', },
+          { name: 'criteria range', },
+          { name: 'criteria', },
+        ],
+        fn: (range: CellValue[][], ...args) => {
+          return XIf('average', range, ...args);
+        },
+      },
 
-          for (const element of base) {
-            if (element) { count++; }
-          }
-          
-          return {
-            type: ValueType.number,
-            value: count,
-          }
+      /** @see CountIf */
+      SumIf: {
+        arguments: [
+          { name: 'range', },
+          { name: 'criteria', },
+        ],
+        fn: (range: CellValue[][], criteria: CellValue, sum_range?: CellValue[][]) => {
+          return XIf('sum', sum_range||range, range, criteria);
+        },
+      },
 
+      /** @see CountIf */
+      SumIfs: {
+        arguments: [
+          { name: 'value range', },
+          { name: 'criteria range', },
+          { name: 'criteria', },
+          { name: 'criteria range', },
+          { name: 'criteria', },
+        ],
+        fn: (range: CellValue[][], ...args) => {
+          return XIf('sum', range, ...args);
         },
       },
 
@@ -680,21 +733,7 @@ export class Calculator extends Graph {
           { name: 'criteria', }
         ],
         fn: (range, criteria): UnionValue => {
-
-          const result = CountIfInternal(range, criteria);
-
-          if (result.type === ValueType.array) {
-            let count = 0;
-            for (const column of (result as ArrayUnion).value) {
-              for (const cell of column) {
-                if (cell.value) { count++; }
-              }
-            }
-            return { type: ValueType.number, value: count };
-          }
-
-          return result; // error
-
+          return XIf('count', range, range, criteria);
         },
       },
 

package/treb-calculator/src/complex-math.ts

@@ -99,6 +99,54 @@ export const RectangularToPolar = (value: Complex): { r: number, theta: number }
   return { r, theta };
 };
 
+export const Tan = (z: Complex) => {
+
+  // tan(a+bi) = (tan(a) + i tanh(b)) / (1 - i tan(a) tanh(b))
+
+  return Divide({
+    real: Math.tan(z.real),
+    imaginary: Math.tanh(z.imaginary),
+  }, {
+    real: 1,
+    imaginary: -(Math.tan(z.real) * Math.tanh(z.imaginary)),
+  });
+
+};
+
+export const Cos = (z: Complex) => {
+   
+  // sin(a+bi) = cos(a) cosh(b) + i sin(a) sinh(b)
+
+  return {
+    real: Math.cos(z.real) * Math.cosh(z.imaginary),
+    imaginary: Math.sin(z.real) * Math.sinh(z.imaginary),
+  };
+
+};
+
+
+export const Sin = (z: Complex) => {
+   
+  // sin(a+bi) = sin(a) cosh(b) + i cos(a) sinh(b)
+
+  return {
+    real: Math.sin(z.real) * Math.cosh(z.imaginary),
+    imaginary: Math.cos(z.real) * Math.sinh(z.imaginary),
+  };
+
+};
+
+export const Product = (...args: Complex[]): Complex => {
+  let base = args.shift();
+  if (!base) { 
+    return { real: 0, imaginary: 0 };
+  }
+  for (const arg of args) {
+    base = Multiply(base, arg);
+  }
+  return base;
+};
+
 export const Multiply = (a: Complex, b: Complex): Complex => {
   return {
     real: (a.real * b.real) - (a.imaginary * b.imaginary),

package/treb-calculator/src/dag/graph.ts

@@ -179,7 +179,10 @@ export abstract class Graph implements GraphCallbacks {
   public GetVertex(address: ICellAddress, create?: boolean): SpreadsheetVertex | undefined {
 
     if (!address.sheet_id) { 
-      console.info({address, create});
+      console.info(JSON.stringify({address, create}));
+      console.trace();
+
+      
       throw new Error('getvertex with no sheet id'); 
     }
 

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

@@ -35,8 +35,11 @@ import { ClickCheckbox, RenderCheckbox } from './checkbox';
 import { UnionIsMetadata } from '../expression-calculator';
 
 import { Exp as ComplexExp, Power as ComplexPower, Multiply as ComplexMultply } from '../complex-math';
+import * as ComplexMath from '../complex-math';
+
 import { CoerceComplex } from './function-utilities';
 import type { UnitAddress, UnitRange } from 'treb-parser';
+import { ConstructDate } from './date-utils';
 
 /**
  * BaseFunctionLibrary is a static object that has basic spreadsheet
@@ -77,6 +80,22 @@ const erf = (x: number): number => {
 
 const sqrt2pi = Math.sqrt(2 * Math.PI);
 
+const norm_dist = (x: number, mean: number, stdev: number, cumulative: boolean) => {
+  
+  let value = 0;
+
+  if (cumulative) {
+    const sign = (x < mean) ? -1 : 1;
+    value = 0.5 * (1.0 + sign * erf((Math.abs(x - mean)) / (stdev * Math.sqrt(2))));
+  }
+  else {
+    value = Math.exp(-1/2 * Math.pow((x - mean) / stdev, 2)) / (stdev * sqrt2pi);
+  }
+
+  return value;
+
+}
+
 /** imprecise but reasonably fast normsinv function */
 const inverse_normal = (q: number): number => {
 
@@ -93,6 +112,7 @@ const inverse_normal = (q: number): number => {
 
 };
 
+
 const edate_calc = (start: number, months: number) => {
   
   let date = new Date(LotusDate(start));
@@ -519,36 +539,18 @@ export const BaseFunctionLibrary: FunctionMap = {
   },
 
   Date: {
-    description: 'Constructs a Lotus date from parts',
+    description: 'Constructs a date from year/month/day',
     arguments: [
       { name: 'year', unroll: true },
       { name: 'month', unroll: true },
       { name: 'day', unroll: true },
     ],
     fn: (year: number, month: number, day: number) => {
-      const date = new Date();
-      date.setMilliseconds(0);
-      date.setSeconds(0);
-      date.setMinutes(0);
-      date.setHours(0);
-      
-      if (year < 0 || year > 10000) { 
+      const date = ConstructDate(year, month, day);
+      if (date === false) {
         return ArgumentError();
       }
-      if (year < 1899) { year += 1900; }
-      date.setFullYear(year);
-
-      if (month < 1 || month > 12) {
-        return ArgumentError();
-      }
-      date.setMonth(month - 1);
-
-      if (day < 1 || day > 31) {
-        return ArgumentError();
-      }
-      date.setDate(day);
-
-      return { type: ValueType.number, value: UnlotusDate(date.getTime()) };
+      return { type: ValueType.number, value: date };
     },
   },
 
@@ -2122,6 +2124,22 @@ export const BaseFunctionLibrary: FunctionMap = {
       }
     },
 
+    'Norm.S.Inv': {
+      description: 'Inverse of the normal cumulative distribution', 
+      arguments: [
+        {name: 'probability'},
+        {name: 'mean', default: 0},
+        {name: 'standard deviation', default: 1},
+      ],
+      xlfn: true,
+      fn: (q: number, mean = 0, stdev = 1): UnionValue => {
+        return {
+          type: ValueType.number,
+          value: inverse_normal(q) * stdev + mean,
+        }
+      }
+    }, 
+
     'Norm.Dist': {
 
       description: 'Cumulative normal distribution',
@@ -2138,22 +2156,22 @@ export const BaseFunctionLibrary: FunctionMap = {
       xlfn: true,
 
       fn: (x: number, mean = 0, stdev = 1, cumulative = true): UnionValue => {
+        return { type: ValueType.number, value: norm_dist(x, mean, stdev, cumulative) };
+      },
+    },
 
-        let value = 0;
+    'Norm.S.Dist': {
 
-        if (cumulative) {
-          const sign = (x < mean) ? -1 : 1;
-          value = 0.5 * (1.0 + sign * erf((Math.abs(x - mean)) / (stdev * Math.sqrt(2))));
-        }
-        else {
-          value = Math.exp(-1/2 * Math.pow((x - mean) / stdev, 2)) / (stdev * sqrt2pi);
-        }
+      description: 'Cumulative normal distribution',
+      arguments: [
+        {name: 'value'},
+        {name: 'cumulative', default: true},
+      ],
 
-        return { 
-          type: ValueType.number, 
-          value,
-        };
+      xlfn: true,
 
+      fn: (x: number, cumulative = true): UnionValue => {
+        return { type: ValueType.number, value: norm_dist(x, 0, 1, cumulative) };
       },
     },
 
@@ -2437,6 +2455,60 @@ export const BaseFunctionLibrary: FunctionMap = {
           return ArgumentError();
         }
   
+      },
+    },
+
+    Sin: {
+      arguments: [
+        { name: 'angle in radians', boxed: true, unroll: true, }
+      ],
+      fn: (a: UnionValue) => {
+
+        if (a.type === ValueType.number) {
+          return { type: ValueType.number, value: Math.sin(a.value) };
+        }
+        if (a.type === ValueType.complex) {
+          return { type: ValueType.complex, value: ComplexMath.Sin(a.value) }; 
+        }
+
+        return ArgumentError();
+
+      },
+    },
+
+    Cos: {
+      arguments: [
+        { name: 'angle in radians', boxed: true, unroll: true, }
+      ],
+      fn: (a: UnionValue) => {
+
+        if (a.type === ValueType.number) {
+          return { type: ValueType.number, value: Math.cos(a.value) };
+        }
+        if (a.type === ValueType.complex) {
+          return { type: ValueType.complex, value: ComplexMath.Cos(a.value) }; 
+        }
+
+        return ArgumentError();
+
+      },
+    },
+    
+    Tan: {
+      arguments: [
+        { name: 'angle in radians', boxed: true, unroll: true, }
+      ],
+      fn: (a: UnionValue) => {
+
+        if (a.type === ValueType.number) {
+          return { type: ValueType.number, value: Math.tan(a.value) };
+        }
+        if (a.type === ValueType.complex) {
+          return { type: ValueType.complex, value: ComplexMath.Tan(a.value) }; 
+        }
+
+        return ArgumentError();
+
       },
     }