@trebco/treb 27.0.1 → 27.2.1

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v27.0. Copyright 2018-2023 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v27.2. Copyright 2018-2023 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": "27.0.1",
+  "version": "27.2.1",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {
@@ -13,8 +13,8 @@
   "devDependencies": {
     "@types/html-minifier": "^4.0.2",
     "@types/node": "^20.4.0",
-    "@typescript-eslint/eslint-plugin": "^5.30.4",
-    "@typescript-eslint/parser": "^5.30.4",
+    "@typescript-eslint/eslint-plugin": "^6.1.0",
+    "@typescript-eslint/parser": "^6.1.0",
     "archiver": "^5.3.0",
     "cssnano": "^6.0.0",
     "esbuild": "^0.18.11",

package/treb-calculator/src/calculator.ts

@@ -811,6 +811,33 @@ export class Calculator extends Graph {
         },
       },
 
+
+  /** not sure when this one appeared, but it's what I was looking for */
+      FormulaText: {
+        description: 'Returns a formula as a string',
+        arguments: [
+          { name: 'reference', description: 'Cell reference', metadata: true, },
+        ],
+        fn: Utilities.ApplyAsArray((reference: UnionValue): UnionValue => {
+
+          if (!UnionIsMetadata(reference)) {
+            return ReferenceError();
+          }
+
+          const sheet = this.model.sheets.Find(reference.value?.address?.sheet_id || 0);
+          if (sheet) {
+            const cell = sheet.cells.GetCell(reference.value.address, false);
+            return { 
+              type: ValueType.string, 
+              value: cell?.value?.toString() || '',
+            };
+          }
+          
+          return ReferenceError();
+
+        }),
+      },
+
       /**
        * this should be in the 'information' library but it needs reference
        * to the underlying cell (unresolved)

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

@@ -23,6 +23,8 @@ import type { FunctionMap } from '../descriptors';
 import { type CellValue, type UnionValue, ValueType } from 'treb-base-types';
 import { FlattenUnboxed } from '../utilities';
 
+import { ArgumentError, ReferenceError, UnknownError, ValueError, ExpressionError, NAError, DivideByZeroError } from '../function-error';
+
 // use a single, static object for base functions
 
 /**
@@ -114,6 +116,189 @@ export const FinanceFunctionLibrary: FunctionMap = {
     }
   },
 
+  XNPV: {
+    description: 'returns the NPV of a nonperiodic stream of payments at a given rate',
+    arguments: [
+      { name: 'Discount rate', },
+      { name: 'Values', },
+      { name: 'Dates', },
+    ],
+    fn: (rate: UnionValue, input_values: CellValue[], input_dates: CellValue[]): UnionValue => {
+
+      if (typeof rate !== 'number') {
+        return ArgumentError();
+      }
+
+      input_values = FlattenUnboxed(input_values);
+      input_dates = FlattenUnboxed(input_dates);
+
+      // some validation...
+
+      if (input_values.length !== input_dates.length) {
+        return ArgumentError();
+      }
+
+      const values: number[] = [];
+
+      for (const value of input_values) {
+        if (typeof value !== 'number') {
+          return ArgumentError();
+        }
+        values.push(value);
+      }
+
+      const dates: number[] = [];
+
+      //
+      // "Numbers in dates are truncated to integers."
+      //
+      // https://support.microsoft.com/en-gb/office/xirr-function-de1242ec-6477-445b-b11b-a303ad9adc9d
+      //
+      // what does that mean? rounded? floored? going to assume the latter...
+
+      for (const date of input_dates) {
+        if (typeof date !== 'number') {
+          return ArgumentError();
+        }
+        dates.push(Math.floor(date));
+      }
+
+      let npv = 0;
+
+      for (let j = 0; j < values.length; j++) { 
+        npv += (values[j] || 0) / Math.pow((1 + rate), (dates[j] - dates[0]) / 365);
+      }
+
+      return {
+        type: ValueType.number,
+        value: npv,
+      };
+
+    }
+  },
+
+  XIRR: {
+    description: 'returns the internal rate of return of a nonperiodic stream of payments',
+    arguments: [
+      { name: 'Values', },
+      { name: 'Dates', },
+      { name: 'Guess', default: .1 },
+    ],
+    fn: (input_values: CellValue[], input_dates: CellValue[], guess = .1): UnionValue => {
+
+      input_values = FlattenUnboxed(input_values);
+      input_dates = FlattenUnboxed(input_dates);
+
+      // some validation...
+
+      if (input_values.length !== input_dates.length) {
+        return ArgumentError();
+      }
+
+      let positive = 0;
+      let negative = 0;
+
+      const values: number[] = [];
+
+      for (const value of input_values) {
+        if (typeof value !== 'number') {
+          // console.info('value not number', value);
+          return ArgumentError();
+        }
+        if (value > 0) { positive++; }
+        if (value < 0) { negative++; }
+
+        values.push(value);
+      }
+
+      if (positive <= 0 || negative <= 0) {
+        // console.info('invalid -/+ count', positive, negative);
+        return ArgumentError();
+      }
+
+      const dates: number[] = [];
+
+      //
+      // "Numbers in dates are truncated to integers."
+      //
+      // https://support.microsoft.com/en-gb/office/xirr-function-de1242ec-6477-445b-b11b-a303ad9adc9d
+      //
+      // what does that mean? rounded? floored? going to assume the latter...
+
+      for (const date of input_dates) {
+        if (typeof date !== 'number') {
+          return ArgumentError();
+        }
+        dates.push(Math.floor(date));
+      }
+
+      const start = dates[0];
+      for (const date of dates) {
+        if (date < start) {
+          return ArgumentError(); 
+        }
+      }
+
+      // per the above reference link we have max steps = 100 and 
+      // resolution threshold = 1e-8 ("0.000001 percent")
+
+      const step = .1; // initial step
+
+      const bounds = [
+        {found: false, value: 0},
+        {found: false, value: 0},
+      ];
+
+      const count = values.length;
+
+      for (let i = 0; i < 100; i++) {
+
+        // calculate npv
+        let npv = 0;
+
+        for (let j = 0; j < count; j++) { 
+          npv += (values[j] || 0) / Math.pow((1 + guess), (dates[j] - dates[0]) / 365);
+        }
+
+        if (Math.abs(npv) <= 1e-6) { // resolution
+          // console.info(`** found in ${i + 1} steps`)
+          return {
+            type: ValueType.number,
+            value: guess,
+          }
+        }
+
+        // search space is unbounded, unfortunately. we can expand exponentially
+        // until we have bounds, at which point it's a standard bounded binary search
+
+        // ...or we can expand linearly, using a reasonable initial step size?
+
+        if (npv > 0) {
+          bounds[0].value = bounds[0].found ? Math.max(bounds[0].value, guess) : guess;
+          bounds[0].found = true;
+          if (!bounds[1].found) {
+            guess += step;
+            continue;
+          }
+        }
+        else {
+          bounds[1].value = bounds[1].found ? Math.min(bounds[1].value, guess) : guess;
+          bounds[1].found = true;
+          if (!bounds[0].found) {
+            guess -= step;
+            continue;
+          }
+        }
+
+        guess = bounds[0].value + (bounds[1].value - bounds[0].value) / 2;
+
+      }
+      
+      return ValueError();
+
+    },
+  },
+
   IRR: {
     description: 'Calculates the internal rate of return of a series of cashflows',
     arguments: [

package/treb-embed/src/embedded-spreadsheet.ts

@@ -887,6 +887,9 @@ export class EmbeddedSpreadsheet {
       if (data) {
         this.LoadDocument(data as TREBDocument, { recalculate: !!this.options.recalculate, source});
       }
+      else {
+        this.UpdateDocumentStyles();
+      }
     }
     else if (!network_document) {
 
@@ -894,6 +897,7 @@ export class EmbeddedSpreadsheet {
       // and the calculator, which would otherwise happen on document load
 
       this.calculator.RebuildClean(true);
+      this.UpdateDocumentStyles();
 
     }
 
@@ -2410,17 +2414,7 @@ export class EmbeddedSpreadsheet {
       }
 
       if (blob) {
-
-        /*
-        const a = document.createElement('a');
-        a.href = URL.createObjectURL(blob);
-        a.download = filename + '.xlsx';
-        a.click();
-        URL.revokeObjectURL(a.href);
-        // FileSaver.saveAs(blob, filename + '.xlsx', { autoBom: false });
-        */
         this.SaveAs(blob, filename + '.xlsx');
-
         this.last_save_version = this.file_version; // even though it's an export, consider it clean
       }
 

package/treb-export/src/export2.ts

@@ -796,13 +796,13 @@ export class Exporter {
             case 'png':
             case 'gif':
 
-              if (annotation.rect) {
+              if (annotation.layout) {
                 images.push({
-                  anchor: this.AnnotationRectToAnchor(annotation.rect, sheet_source), options});
+                  anchor: this.AnnotationLayoutToAnchor(annotation.layout, sheet_source), options});
               }
-              else if (annotation.layout) {
+              else if (annotation.rect) {
                 images.push({
-                  anchor: this.AnnotationLayoutToAnchor(annotation.layout, sheet_source), options});
+                  anchor: this.AnnotationRectToAnchor(annotation.rect, sheet_source), options});
               }
               else {
                 console.warn('annotation missing layout');
@@ -1006,16 +1006,16 @@ export class Exporter {
 
           const rect = (annotation as AnnotationData & { rect?: Partial<Rectangle>}).rect;
 
-          if (rect) {
-            charts.push({
-              anchor: this.AnnotationRectToAnchor(rect, sheet_source), options});
-            // sheet.AddChart(this.AnnotationRectToAnchor(annotation.rect, sheet_source), options);
-          }
-          else if (annotation.layout) {
+          if (annotation.layout) {
             charts.push({
               anchor: this.AnnotationLayoutToAnchor(annotation.layout, sheet_source), options});
             // sheet.AddChart(this.AnnotationLayoutToAnchor(annotation.layout, sheet_source), options);
           }
+          else if (rect) {
+            charts.push({
+              anchor: this.AnnotationRectToAnchor(rect, sheet_source), options});
+            // sheet.AddChart(this.AnnotationRectToAnchor(annotation.rect, sheet_source), options);
+          }
           else {
             console.warn('annotation missing layout');
           }