@trebco/treb 29.1.6 → 29.3.1

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v29.1. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v29.3. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map
@@ -1602,19 +1602,23 @@ export interface SerializedNamedExpression {
 }
 
 /**
- * serialized type
+ * serialized type is a composite of expression/range. we determine
+ * what it is when parsing the expression. this simplifies passing these
+ * things around.
+ *
+ * (named expressions and ranges they have slightly different behavior,
+ * which is why we have a distinction at all).
+ *
  */
 export interface SerializedNamed {
     name: string;
-    area?: SerializedArea;
-    expression?: string;
+
+    /** expression or address/area */
+    expression: string;
+
+    /** scope is a sheet name (not ID) */
     scope?: string;
 }
-export type SerializedArea = IArea & {
-    start: ICellAddress & {
-        sheet: string;
-    };
-};
 export interface SerializedSheet {
 
     /** cell data */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trebco/treb",
-  "version": "29.1.6",
+  "version": "29.3.1",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {

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

@@ -102,6 +102,9 @@ export interface Dimensions {
  * start/end value for row/column/both, so watch out on loops. the
  * sheet class has a method for reducing infinite ranges to actual
  * populated ranges.
+ * 
+ * infinitiy is turning into a headache because it doesn't serialize
+ * to json properly. should we switch to a flag, or -1, or something?
  */
 export class Area implements IArea {
 
@@ -166,6 +169,10 @@ export class Area implements IArea {
 
   public static CellAddressToLabel(address: ICellAddress, sheet_id = false): string {
 
+    if (address.row === Infinity || address.column === Infinity) {
+      throw new Error('this is going to break something');
+    }
+
     const prefix = sheet_id ? `${address.sheet_id || 0}!` : '';
 
     return prefix

package/treb-calculator/src/calculator.ts

@@ -1930,12 +1930,15 @@ export class Calculator extends Graph {
       }
     }
 
+    /*
     if (area.count > 1) {
       range = Area.CellAddressToLabel(area.start) + ':' + Area.CellAddressToLabel(area.end);
     }
     else {
       range = Area.CellAddressToLabel(area.start);
     }
+    */
+    range = area.spreadsheet_label;
 
     if (!qualified) {
       return range;
@@ -2514,21 +2517,20 @@ export class Calculator extends Graph {
         const unit = dependencies.ranges[key];
         const range = new Area(unit.start, unit.end);
 
-        for (const address of range) {
-          this.AddLeafVertexEdge(address, vertex);
+        if (range.entire_column || range.entire_row || range.count > 1) {
+          // this.AddLeafVertexEdge(range.start, vertex);
+          this.AddLeafVertexArrayEdge(range, vertex);
+        }
+        else {
+          this.AddLeafVertexEdge(range.start, vertex);
         }
-
-        /*
-        range.Iterate((address: ICellAddress) => {
-          this.AddLeafVertexEdge(address, vertex);
-        });
-        */
 
         /*
         for (const address of range) {
           this.AddLeafVertexEdge(address, vertex);
         }
         */
+
       }
 
       for (const key of Object.keys(dependencies.addresses)){

package/treb-calculator/src/dag/array-vertex.ts

@@ -101,11 +101,9 @@ export class ArrayVertex extends SpreadsheetVertexBase {
    * returns a list of arrays that contain this address
    */
   public static GetContainingArrays(address: ICellAddress2): ArrayVertex[] {
-    // console.info('av2 get arrays:', address.row, address.column);
     const list: ArrayVertex[] = [];
     for (const entry of this.list) {
       if ((entry.area.start.sheet_id === address.sheet_id) && entry.area.Contains(address)) {
-        // console.info("match", entry.area.spreadsheet_label);
         list.push(entry);
       }
     }

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

@@ -613,9 +613,91 @@ export abstract class Graph implements GraphCallbacks {
   /** 
    * new array vertices
    */
-  public AddArrayEdge(u: Area, v: ICellAddress): void {
+  protected CompositeAddArrayEdge(u: Area, vertex: Vertex): void {
+
+    if (!u.start.sheet_id) {
+      throw new Error('AddArrayEdge called without sheet ID');
+    }
+
+    // create or use existing
+    const [array_vertex, created] = ArrayVertex.GetVertex(u);
+
+    // add an edge
+    vertex.DependsOn(array_vertex);
+
+    // force a check on next calculation pass
+    this.loop_check_required = true;
+
+    if (!created) {
+      // console.info('reusing, so not adding edges');
+      return;
+    }
+
+    // now add edges from/to nodes THAT ALREADY EXIST
+
+    // range can't span sheets, so we only need one set to look up
+
+    const map = this.vertices[u.start.sheet_id];
+
+    // this might happen on create, we can let it go because the 
+    // references will be added when the relevant sheet is added
+
+    if (!map) {
+      return;
+    }
+
+    // ...
+
+    if (u.entire_row) {
+      // console.group('entire row(s)')
+      for (let column = 0; column < map.length; column++) {
+        if (map[column]) {
+          for (let row = u.start.row; row <= u.end.row; row++ ) {
+            const vertex = map[column][row];
+            if (vertex) {
+              // console.info('add', column, row);
+              array_vertex.DependsOn(vertex);
+            }
+          }
+        }
+      }
+      // console.groupEnd();
+    }
+    else if (u.entire_column) {
+      // console.group('entire column(s)');
+      for (let column = u.start.column; column <= u.end.column; column++) {
+        if(map[column]) {
+          for (const vertex of map[column]) {
+            if (vertex?.address) {
+              // console.info('add', vertex.address);
+              array_vertex.DependsOn(vertex);
+            }
+          }
+        }
+      }
+      // console.groupEnd();
+    }
+    else {
+      for (let row = u.start.row; row <= u.end.row; row++) {
+        for (let column = u.start.column; column <= u.end.column; column++) {
+          const vertex = map[column][row];
+          if (vertex) {
+            array_vertex.DependsOn(vertex);
+          }
+        }
+      }
+    }
 
-    // console.info('add array edge', u, v);
+  }
+
+  public AddLeafVertexArrayEdge(u: Area, vertex: LeafVertex) {
+    this.CompositeAddArrayEdge(u, vertex);
+  }
+
+  /** 
+   * new array vertices
+   */
+  public AddArrayEdge(u: Area, v: ICellAddress): void {
 
     if (!u.start.sheet_id) {
       throw new Error('AddArrayEdge called without sheet ID');
@@ -624,6 +706,9 @@ export abstract class Graph implements GraphCallbacks {
     // this should have already been added...
     const v_v = this.GetVertex(v, true);
 
+    this.CompositeAddArrayEdge(u, v_v);
+
+    /*
     // create or use existing
     const [array_vertex, created] = ArrayVertex.GetVertex(u);
 
@@ -692,6 +777,7 @@ export abstract class Graph implements GraphCallbacks {
         }
       }
     }
+    */
 
   }
 

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

@@ -226,71 +226,13 @@ export class SpreadsheetVertex extends SpreadsheetVertexBase {
         // handle it properly regardless.
 
         const single = (this.result.type === ValueType.array) ? this.result.value[0][0] : this.result;
-        /*
-        if (single.type === ValueType.object) {
-          this.reference.SetCalculationError('OBJECT');
-        }
-        else */
 
         // we are using object type in the returned value for sparklines...
         // so we can't drop it here. we could change rendering though. or
         // whitelist types. or blacklist types. or something.
 
-        {
-          this.reference.SetCalculatedValue(single.value as CellValue, single.type);
-        }
-
-        /*
-        console.info("T2", t2);
-
-        // because we let sloppy data filter through, it's possible
-        // that we get some random stuff at this point. generally this
-        // shoudl not happen but if you use (e.g.) one of the chart
-        // functions in a spreadsheet cell, you'll get a 1d array.
-
-        // so we need to validate that what we have is either a UnionValue
-        // or a 2d UnionValue[][] array.
-
-        // don't know the performance cost of this.
-
-        // FIXME: don't let sloppy data through.
-
-        let test: any = this.result;
-
-        if (Array.isArray(test)) {
-          if (test[0] && Array.isArray(test[0])) {
-            test = test[0][0];
-          }
-          else {
-            // console.warn('error 1');
-            test = undefined;
-          }
-        }
-
-        if (!test || typeof (test as any).type === undefined) {
-          // console.warn('error 2/3');
-          this.reference.SetCalculationError('UNK');
-        }
-        else {
-          this.reference.SetCalculatedValue((test as UnionValue).value, (test as UnionValue).type);
-        }
-        */
-
-        /*
-        const single = Array.isArray(this.result) ? this.result[0][0] : this.result;
-
-        // error is implicit
-        this.reference.SetCalculatedValue(single.value, single.type);
-        */
+        this.reference.SetCalculatedValue(single.value as CellValue, single.type);
 
-        /*
-        if (typeof this.result === 'object' && this.result.error) {
-          this.reference.SetCalculationError(this.result.error);
-        }
-        else {
-          this.reference.SetCalculatedValue(this.result);
-        }
-        */
       }
 
     }
@@ -318,7 +260,6 @@ export class SpreadsheetVertex extends SpreadsheetVertexBase {
     // 
 
     for (const edge of this.edges_out as Set<SpreadsheetVertexBase>){
-      // (edge as SpreadsheetVertex).Calculate(graph);
       if (edge.dirty) {
         graph.calculation_list.push(edge);
       }

package/treb-calculator/src/expression-calculator.ts

@@ -501,6 +501,11 @@ export class ExpressionCalculator {
     const func = this.library.Get(outer.name);
 
     if (!func) {
+
+      if (process.env.NODE_ENV !== 'production') {
+        console.info('(dev) missing function', outer.name);
+      }
+
       return () => NameError();
     }
 

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

@@ -89,6 +89,45 @@ const inverse_normal = (q: number): number => {
 
 };
 
+const edate_calc = (start: number, months: number) => {
+  
+  let date = new Date(LotusDate(start));
+  let month = date.getUTCMonth() + months;
+  let year = date.getUTCFullYear();
+
+  // if we don't ensure the time we'll wind up hitting boundary cases
+
+  date.setUTCHours(12);
+  date.setUTCMinutes(0);
+  date.setUTCSeconds(0);
+  date.setUTCMilliseconds(0);
+
+  while (month < 0) {
+    month += 12;
+    year--;
+  }
+  while (month > 11) {
+    month -= 12;
+    year++;
+  }
+
+  date.setUTCMonth(month);
+  date.setUTCFullYear(year);
+
+  // if this rolls over the month, then we need to go back to the 
+  // last valid day of the month. so jan 31 + 1 month needs to equal
+  // feb 28 (feb 29 in leap year).
+
+  const check_month = date.getUTCMonth();
+  if (check_month !== month) {
+    const days = date.getUTCDate();
+    date = new Date(date.getTime() - (days * 86400 * 1000));
+  }
+
+  return date;
+
+};
+
 const zlookup_arguments = [
   {
     name: "Lookup value",
@@ -329,6 +368,90 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
   },
 
+  // --- FIXME: break out date functions? --------------------------------------
+
+  EDate: {
+    arguments: [
+      { 
+        name: 'Start date',
+        unroll: true,
+      },
+      {
+        name: 'Months',
+        unroll: true,
+      },
+    ],
+    fn: (start: number, months = 0) => {
+      if (typeof start !== 'number' || typeof months !== 'number') {
+        return ArgumentError();
+      }
+      const date = edate_calc(start, months);
+      return { type: ValueType.number, value: UnlotusDate(date.getTime(), false) };
+    }
+  },
+
+  EOMonth: {
+    arguments: [
+      { 
+        name: 'Start date',
+        unroll: true,
+      },
+      {
+        name: 'Months',
+        unroll: true,
+      },
+    ],
+    fn: (start: number, months = 0) => {
+
+      // this is the same as edate, except it advances to the end of the
+      // month. so jan 15, 2023 plus one month -> feb 28, 2023 (last day).
+
+      if (typeof start !== 'number' || typeof months !== 'number') {
+        return ArgumentError();
+      }
+      const date = edate_calc(start, months);
+
+      const month = date.getUTCMonth();
+      switch (month) {
+        case 1: // feb, special
+          {
+            const year = date.getUTCFullYear();
+
+            // it's a leap year if it is divisible by 4, unless it's also 
+            // divisible by 100 AND NOT divisible by 400. 1900 is grand-
+            // fathered in via an error in Lotus. 
+
+            if (year % 4 === 0 && (year === 1900 || (year % 400 === 0) || (year % 100 !== 0))) {
+              date.setUTCDate(29);
+            } 
+            else {
+              date.setUTCDate(28);
+            }
+          }
+          break;
+
+        case 0: // jan
+        case 2:
+        case 4:
+        case 6: // july
+        case 7: // august
+        case 9:
+        case 11: // dec
+          date.setUTCDate(31);
+          break;
+
+        default:
+          date.setUTCDate(30);
+          break;
+      }
+      
+
+      
+      return { type: ValueType.number, value: UnlotusDate(date.getTime(), false) };
+
+    }
+  },
+
   Now: {
     description: 'Returns current time',
     volatile: true,
@@ -429,6 +552,8 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
   },
 
+  // ---------------------------------------------------------------------------
+
   IfError: {
     description: 'Returns the original value, or the alternate value if the original value contains an error',
     arguments: [{ name: 'original value', allow_error: true, boxed: true }, { name: 'alternate value' }],

package/treb-data-model/src/data_model.ts

@@ -25,7 +25,7 @@ import type { IArea, ICellAddress, Table, CellStyle } from 'treb-base-types';
 import type { SerializedSheet } from './sheet_types';
 import { type ExpressionUnit, type UnitAddress, type UnitStructuredReference, type UnitRange, Parser, QuotedSheetNameRegex, DecimalMarkType, ArgumentSeparatorType } from 'treb-parser';
 import { Area, IsCellAddress, Style } from 'treb-base-types';
-import type { CompositeNamed, SerializedNamed } from './named';
+import type { SerializedNamed } from './named';
 import { NamedRangeManager } from './named';
 
 export interface ConnectedElementType {
@@ -132,36 +132,72 @@ export class DataModel {
    * need to check if something is a range -- if so, it will just be 
    * a single address or range. in that case store it as a named range.
    */
-  public UnserializeComposite(names: CompositeNamed[], active_sheet?: Sheet) {
+  public UnserializeNames(names: SerializedNamed[], active_sheet?: Sheet) {
 
     this.parser.Save();
     this.parser.SetLocaleSettings(DecimalMarkType.Period, ArgumentSeparatorType.Comma);
     
-    const sorted = names.map(named => {
+    //const sorted = names.map(named => {
+    for (const named of names) {
       const parse_result = this.parser.Parse(named.expression); 
       if (parse_result.expression) {
+
+        const scope = (typeof named.scope === 'string') ? this.sheets.ID(named.scope) : undefined;
+
         if (parse_result.expression.type === 'address' || parse_result.expression.type === 'range') {
-          return {
-            ...named,
-            expression: undefined,
-            area: parse_result.expression.type === 'address' ? {
-              start: parse_result.expression,
-              end: parse_result.expression,
-            } : parse_result.expression,
-          } as SerializedNamed;
+
+          const [start, end] = parse_result.expression.type === 'range' ? 
+            [ parse_result.expression.start, parse_result.expression.end, ] : 
+            [ parse_result.expression, parse_result.expression ];
+
+          if (start.sheet) {
+            const area = new Area({...start, sheet_id: this.sheets.ID(start.sheet), }, end);
+  
+            if (area.start.sheet_id) {
+              this.named.SetNamedRange(named.name, area, scope);
+            }
+            else {
+              console.warn("missing sheet ID?", start);
+            }
+
+          }
+          else {
+            console.warn("missing sheet name?", start);
+          }
+
         }
-        return {
-          ...named
-        } as SerializedNamed;
+        else {
+          this.parser.Walk(parse_result.expression, unit => {
+            if (unit.type === 'address' || unit.type === 'range') {
+              if (unit.type === 'range') {
+                unit = unit.start;
+              }
+              if (!unit.sheet_id) {
+                if (unit.sheet) {
+                  unit.sheet_id = this.sheets.ID(unit.sheet);
+                }
+              }
+              if (!unit.sheet_id) {
+                unit.sheet_id = active_sheet?.id;
+              }
+              return false; // don't continue in ranges
+            }
+            return true;
+          });
+
+          this.named.SetNamedExpression(named.name, parse_result.expression, scope);
+        }
+
       }
       return undefined;
-    }).filter((test): test is SerializedNamed => !!test);
+    } // ).filter((test): test is SerializedNamed => !!test);
 
     this.parser.Restore();
-    this.UnserializeNames(sorted, active_sheet);
+    // this.UnserializeNames(sorted, active_sheet);
 
   }
 
+  /*
   public UnserializeNames(names: SerializedNamed[], active_sheet?: Sheet) {
 
     for (const entry of names) {
@@ -218,6 +254,7 @@ export class DataModel {
     }
 
   }
+  */
 
   /**
    * serialize names. ranges are easy, but make sure there's a sheet name
@@ -231,7 +268,7 @@ export class DataModel {
 
       const named: SerializedNamed = {
         name: entry.name,
-        // scope: entry.scope,
+        expression: '',
       };
 
       if (entry.scope) {
@@ -278,11 +315,10 @@ export class DataModel {
 
       }
       else {
-        named.area = {
+
+        const area = {
           start: {
             ...entry.area.start,
-            sheet: this.sheets.Name(entry.area.start.sheet_id || 0) || '',
-            sheet_id: undefined, // in favor of name
             absolute_column: true,
             absolute_row: true,
           },
@@ -292,6 +328,9 @@ export class DataModel {
             absolute_row: true,
           },
         };
+
+        named.expression = this.AddressToLabel(area);
+
       }
 
       list.push(named);

package/treb-data-model/src/index.ts

@@ -30,7 +30,7 @@ export type {
   SerializedMacroFunction,
 } from './data_model';
 
-export type { SerializedNamed, CompositeNamed } from './named';
+export type { SerializedNamed } from './named';
 
 export { Sheet } from './sheet';
 export type { SerializedSheet, FreezePane, LegacySerializedSheet } from './sheet_types';