@trebco/treb 29.2.0 → 29.3.1

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v29.2. 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.2.0",
+  "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

@@ -502,7 +502,9 @@ export class ExpressionCalculator {
 
     if (!func) {
 
-      // console.info('missing function', outer.name);
+      if (process.env.NODE_ENV !== 'production') {
+        console.info('(dev) missing function', outer.name);
+      }
 
       return () => NameError();
     }

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

@@ -416,7 +416,12 @@ export const BaseFunctionLibrary: FunctionMap = {
         case 1: // feb, special
           {
             const year = date.getUTCFullYear();
-            if (year % 4 === 0 && (year === 1900 || (year % 100 !== 0))) {
+
+            // 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 {

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';

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

@@ -20,15 +20,15 @@
  */
 
 import { Area } from 'treb-base-types';
-import type { SerializedArea, IArea } from 'treb-base-types';
+import type { IArea } from 'treb-base-types';
 import type { ExpressionUnit } from 'treb-parser';
 
-export interface NamedExpression {
+interface NamedExpression {
   type: 'expression';
   expression: ExpressionUnit;
 }
 
-export interface NamedRange {
+interface NamedRange {
   type: 'range';
   area: Area;
 }
@@ -38,44 +38,23 @@ export type Named = (NamedExpression | NamedRange) & {
   scope?: number;   // scope to sheet by ID
 };
 
-/** 
- * serialized type 
- * 
- * @privateRemarks
- * 
- * for the external type we switch on the presence of the area
- * or the expression. area uses a type that includes sheet names
- * (IArea should allow that?). expression here is a string.
+/**
+ * serialized type is a composite of expression/range. we determine
+ * what it is when parsing the expression. this simplifies passing these
+ * things around.
  * 
- * we could theoretically switch the internal type the same way
- * and drop the string keys. something to think about.
+ * (named expressions and ranges they have slightly different behavior, 
+ * which is why we have a distinction at all).
  * 
- * when serialized, scope is either the sheet name or nothing 
- * (implicit global scope).
  */
 export interface SerializedNamed {
-  name: string;
-  area?: SerializedArea;
-  expression?: string;
-  scope?: string;
-}
-
-/**
- * this is a type we're using in imports. it consolidates the 
- * two types. we should maybe switch as well, at least for
- * serialized representation? something to think about.
- */
-export interface CompositeNamed {
 
   name: string;
 
-  /** 
-   * could be a address/range or a function expression. we'll distinguish
-   * when we parse it.
-   */
+  /** expression or address/area */
   expression: string;
 
-  /** resolved sheet name */
+  /** scope is a sheet name (not ID) */
   scope?: string;
 
 }

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

@@ -3282,9 +3282,20 @@ export class Sheet {
       // stop rule. if you go forwards, you need some sort of indicator 
       // or flag).
 
+      const area = JSON.parse(JSON.stringify(format.area));
+      
+      if (area.start.row === null || area.end.row === null) {
+        area.start.row = 0;
+        area.end.row = this.cells.rows - 1;
+      }
+      if (area.start.column === null || area.end.column === null) {
+        area.start.column = 0;
+        area.end.column = this.cells.columns - 1;
+      }
+
+      const result = format.internal?.vertex?.result;
+
       if (format.type === 'gradient') {
-        const area = JSON.parse(JSON.stringify(format.area));
-        const result = format.internal?.vertex?.result;
 
         if (result && format.internal?.gradient) {
           const property: 'fill'|'text' = format.property ?? 'fill';
@@ -3322,16 +3333,13 @@ export class Sheet {
 
         // handle types expression, cell-match and duplicate-values
 
-        const area = JSON.parse(JSON.stringify(format.area));
-        const result = format.internal?.vertex?.result;
-
         if (result) {
 
           if (result.type === ValueType.array) {
             for (let row = area.start.row; row <= area.end.row; row++) {
               for (let column = area.start.column; column <= area.end.column; column++) {
                 const value = result.value[column - area.start.column][row - area.start.row];
-                if ((value.type === ValueType.boolean || value.type === ValueType.number) && !!value.value) {
+                if (value && (value.type === ValueType.boolean || value.type === ValueType.number) && !!value.value) {
                   if (!temp[row]) { temp[row] = []; }
                   if (!temp[row][column] ) { temp[row][column] = []; }
                   temp[row][column].push(format.style);