@trebco/treb 29.8.4 → 30.1.0

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

@@ -30,6 +30,8 @@ import { Area } from 'treb-base-types';
 import type { DataModel } from 'treb-data-model';
 import { CalculationLeafVertex } from './calculation_leaf_vertex';
 
+import { AreaUtils } from 'treb-base-types';
+
 export type LeafVertex = StateLeafVertex|CalculationLeafVertex;
 export type { StateLeafVertex };
 
@@ -55,6 +57,10 @@ export abstract class Graph implements GraphCallbacks {
 
   public calculation_list: SpreadsheetVertexBase[] = [];
 
+  // list of spills we have created
+  // public spills: IArea[] = [];
+  public spill_data: { area: IArea, vertex: StateLeafVertex }[] = [];
+
   // public cells_map: {[index: number]: Cells} = {};
 
   protected abstract readonly model: DataModel;
@@ -110,6 +116,9 @@ export abstract class Graph implements GraphCallbacks {
     this.leaf_vertices.clear(); 
     // this.cells_map = {};
 
+    // can we flush spills here without cleaning up? (...)
+    // this.spills = [];
+
     /** array vertex maintains its own list */
     ArrayVertex.Clear();
 
@@ -142,6 +151,24 @@ export abstract class Graph implements GraphCallbacks {
 
   }
 
+  /**
+   * iterate vertices
+   * @param area 
+   */
+  public *IterateVertices(area: IArea, create = false): Generator<SpreadsheetVertex> {
+
+    // this is wasteful because it repeatedly gets the cells, but
+    // for a contiguous area we know they're in the same sheet. we
+    // cal also skip the repeated tests. FIXME
+
+    for (const address of AreaUtils.Iterate(area)) {
+      const vertex = this.GetVertex(address, create);
+      if (vertex) {
+        yield vertex;
+      }
+    }
+  }
+
   /** overload */
   public GetVertex(address: ICellAddress, create: true): SpreadsheetVertex;
 
@@ -717,77 +744,6 @@ export abstract class Graph implements GraphCallbacks {
 
     this.CompositeAddArrayEdge(u, v_v);
 
-    /*
-    // create or use existing
-    const [array_vertex, created] = ArrayVertex.GetVertex(u);
-
-    // add an edge
-    v_v.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);
-          }
-        }
-      }
-    }
-    */
-
   }
 
   /** adds an edge from u -> v */
@@ -997,16 +953,101 @@ export abstract class Graph implements GraphCallbacks {
     //  vertex.SetDirty();
     // }
 
-    // const calculation_list = this.volatile_list.slice(0).concat(this.dirty_list);
-
-    // we do this using the local function so we can trace back arrays
+    // we do this using the local function so we can trace back arrays.
+    // be sure to do this _before_ checking spills
 
     for (const vertex of this.volatile_list) {
       this.SetVertexDirty(vertex as SpreadsheetVertex);
     }
-    // const calculation_list = this.dirty_list.slice(0);
+    
+
+    ////////////////////////////////////////
+
+    // (moving this up so it comes before we slice the dirty list)
+
+    // the problem with flushing all the spills here
+    // is that if we're not calculating a range that
+    // intersects with the spill, it will disappear.
+    // options are (1) to dirty the spill root, so it
+    // calculates, or (2) to check for intersection.
+
+    // checking for intersection might work because 
+    // we should have vertices and they should be marked
+    // as dirty...
+
+    // eh that's not going to work, because edges point
+    // the wrong way. if you edit a cell within a spill 
+    // range, it won't dirty the spill source because
+    // the edge goes from spill source -> spill cell.
+
+    // we could create a special leaf vertex to watch the 
+    // range. or we could just check here. vertices is 
+    // more elegant (and more memory), this is clumsier (and 
+    // more calc). 
+    
+    this.spill_data = this.spill_data.filter(({area, vertex}) => {
+      if (vertex.dirty) {
+        vertex.Reset(); 
+        const cells = area.start.sheet_id ? this.model.sheets.Find(area.start.sheet_id)?.cells : undefined;
+        if (cells) {
+          for (const {cell, row, column} of cells.IterateRC(new Area(area.start, area.end))) {
+            if (cell.spill) {
+              cell.spill = undefined;
+              if (typeof cell.value === 'undefined') {
+                cell.Reset();
+              }
+            }
+
+            // this is necessary for non-head cells in case the cell has deps
+            this.SetDirty({row, column, sheet_id: area.start.sheet_id});
+
+          }
+          // this.SetDirty(area.start);
+        }
+        return false; // drop
+      }
+      return true; // keep
+    });
+
+    /*
+    this.spills = this.spills.filter(spill => {
+      let dirty = false;
+      for (const vertex of this.IterateVertices(spill)) {
+        if (vertex.dirty) {
+          console.info("spill is dirty (it)");
+          dirty = true;
+          break;
+        }
+      }
+
+      if (dirty) {
+        const cells = spill.start.sheet_id ? this.model.sheets.Find(spill.start.sheet_id)?.cells : undefined;
+        if (cells) {
+          for (const {cell, row, column} of cells.IterateRC(new Area(spill.start, spill.end))) {
+            if (cell.spill) {
+              cell.spill = undefined;
+              if (typeof cell.value === 'undefined') {
+                cell.Reset();
+              }
+              else {
+                this.SetDirty({row, column, sheet_id: spill.start.sheet_id})
+              }
+            }
+          }
+        }
+        return false; // drop
+      }
+
+      return true; // keep
+    });
+    */
+
+    //////////////////////////////////////////
+
     this.calculation_list = this.dirty_list.slice(0);
 
+    // console.info("CL", this.calculation_list);
+
     this.volatile_list = [];
     this.dirty_list = [];
 
@@ -1018,6 +1059,7 @@ export abstract class Graph implements GraphCallbacks {
 
     }
 
+
     // console.info("CL", calculation_list)
 
     // recalculate everything that's dirty. FIXME: optimize path
@@ -1036,9 +1078,8 @@ export abstract class Graph implements GraphCallbacks {
   }
 
   public abstract CalculationCallback(vertex: SpreadsheetVertexBase): CalculationResult;
-
   public abstract SpreadCallback(vertex: SpreadsheetVertexBase, value: UnionValue): void;
-
+  public abstract SpillCallback(vertex: SpreadsheetVertexBase, value: UnionValue): void;
   protected abstract CheckVolatile(vertex: SpreadsheetVertex): boolean;
 
 }

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

@@ -219,20 +219,49 @@ export class SpreadsheetVertex extends SpreadsheetVertexBase {
       }
       else if (this.reference.type === ValueType.formula) {
 
-        // data should now be clean when it gets here (famous last words)
+        // adding check for spill, not withstanding the below
 
-        // we're now sometimes getting 0-length arrays here. that's a 
-        // function of our new polynomial methods, BUT, we should probably
-        // handle it properly regardless.
+        if (this.result.type === ValueType.array) {
 
-        const single = (this.result.type === ValueType.array) ? this.result.value[0][0] : this.result;
+          // note array of length 1 should not trigger spill behavior
+          // (moved to callback method)
 
-        // 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.
+          const recalc = graph.SpillCallback.call(graph, this, this.result);
+          if (recalc) {
+            // console.info("RC", recalc);
+            for (const entry of (recalc as SpreadsheetVertex[])) {
 
-        this.reference.SetCalculatedValue(single.value as CellValue, single.type);
+              // will this work properly with loops? (...)
 
+              for (const edge of entry.edges_out) {
+                (edge as SpreadsheetVertex).dirty = true;
+                (edge as SpreadsheetVertex).Calculate(graph);
+              }
+
+            }
+          }
+
+        }
+        else {
+
+          // ---
+
+
+          // data should now be clean when it gets here (famous last words)
+
+          // we're now sometimes getting 0-length arrays here. that's a 
+          // function of our new polynomial methods, BUT, we should probably
+          // handle it properly regardless.
+
+          // neven // const single = (this.result.type === ValueType.array) ? this.result.value[0][0] : this.result;
+
+          // 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(this.result.value as CellValue, this.result.type);
+
+        }
       }
 
     }

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

@@ -34,6 +34,7 @@ export interface CalculationResult {
 export interface GraphCallbacks {
   CalculationCallback: (vertex: SpreadsheetVertexBase) => CalculationResult;
   SpreadCallback: (vertex: SpreadsheetVertexBase, value: UnionValue) => void;
+  SpillCallback: (vertex: SpreadsheetVertexBase, value: UnionValue) => Vertex[]|void;
   volatile_list: SpreadsheetVertexBase[];
   calculation_list: SpreadsheetVertexBase[];
 }

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

@@ -31,7 +31,7 @@ import { ValueType, GetValueType, Area } from 'treb-base-types';
 import type { Parser, ExpressionUnit, UnitBinary, UnitIdentifier,
          UnitGroup, UnitUnary, UnitAddress, UnitRange, UnitCall, UnitDimensionedQuantity, UnitStructuredReference } from 'treb-parser';
 import type { DataModel, MacroFunction, Sheet } from 'treb-data-model';
-import { NameError, ReferenceError, ExpressionError, UnknownError } from './function-error';
+import { NameError, ReferenceError, ExpressionError, UnknownError, SpillError } from './function-error';
 import { ReturnType } from './descriptors';
 
 import * as Primitives from './primitives';
@@ -136,7 +136,6 @@ export class ExpressionCalculator {
       }
     }
 
-    // const cells = this.cells_map[expr.sheet_id];
     const cells = this.data_model.sheets.Find(expr.sheet_id)?.cells;
 
     if (!cells) {
@@ -156,6 +155,12 @@ export class ExpressionCalculator {
       };
     }
 
+    if (expr.spill && cell.spill && cell.spill.start.row === expr.row && cell.spill.start.column === expr.column) {
+      return () => {
+        return cell.spill ? cells.GetRange4(cell.spill.start, cell.spill.end, true) || ReferenceError() : SpillError();
+      }
+    }
+
     // close
     return () => cell.GetValue4();
 

package/treb-calculator/src/function-error.ts

@@ -34,6 +34,7 @@ export enum ErrorType {
   Div0 =        'DIV/0',
   NA =          'N/A',
   Loop =        'LOOP', // circular reference
+  Spill =       'SPILL',
 }
 
 export interface FunctionError {
@@ -74,6 +75,10 @@ export const NameError = (): UnionValue => {
   return { type: ValueType.error, value: ErrorType.Name };
 };
 
+export const SpillError = (): UnionValue => {
+  return { type: ValueType.error, value: ErrorType.Spill };
+};
+
 export const UnknownError = (): UnionValue => {
   return { type: ValueType.error, value: ErrorType.Unknown };
 };
@@ -94,6 +99,7 @@ export const IsError = (test: unknown): test is FunctionError => {
     (test as FunctionError).error === ErrorType.Unknown ||
     (test as FunctionError).error === ErrorType.NotImpl ||
     (test as FunctionError).error === ErrorType.Value ||
+    (test as FunctionError).error === ErrorType.Spill ||
     (test as FunctionError).error === ErrorType.Div0
   );
 };

package/treb-charts/src/chart-functions.ts

@@ -20,7 +20,7 @@
  */
 
 import { type UnionValue, ValueType } from 'treb-base-types';
-import type { FunctionMap } from 'treb-calculator/src/descriptors';
+import type { CompositeFunctionDescriptor } from 'treb-calculator/src/descriptors';
 
 /** 
  * function returns its arguments 
@@ -35,10 +35,25 @@ const Identity = (...args: unknown[]): UnionValue => {
   };
 };
 
+export type ChartFunction
+  = 'Bar.Chart'
+  | 'Line.Chart'
+  | 'Area.Chart'
+  | 'Column.Chart'
+  | 'Bubble.Chart'
+  | 'Donut.Chart'
+  | 'Pie.Chart'
+  | 'Scatter.Line'
+  | 'Scatter.Plot'
+  | 'Box.Plot'
+  ;
+
+type SupportFunction = 'Group'|'Series';
+
 /**
  * chart functions for registration
  */
-export const ChartFunctions: FunctionMap = {
+export const ChartFunctions: Record<ChartFunction|SupportFunction, CompositeFunctionDescriptor> = {
 
   /* new: also helper */
   Group: {
@@ -52,7 +67,8 @@ export const ChartFunctions: FunctionMap = {
         key: 'group',
       };
 
-    }
+    },
+    category: ['grouping'],
   },
 
   /**
@@ -81,8 +97,8 @@ export const ChartFunctions: FunctionMap = {
         value: args,
         key: 'series',
       };
-    }
-
+    },
+    category: ['chart functions'],
   },
 
   'Bar.Chart': {
@@ -92,6 +108,7 @@ export const ChartFunctions: FunctionMap = {
       { name: 'ChartTitle' },
     ],
     fn: Identity,
+    category: ['chart functions'],
   },
 
   'Line.Chart': {
@@ -101,6 +118,7 @@ export const ChartFunctions: FunctionMap = {
       { name: 'ChartTitle' },
     ],
     fn: Identity,
+    category: ['chart functions'],
   },
 
   'Area.Chart': {
@@ -110,6 +128,7 @@ export const ChartFunctions: FunctionMap = {
       { name: 'ChartTitle' },
     ],
     fn: Identity,
+    category: ['chart functions'],
   },
 
   'Pie.Chart': {
@@ -121,6 +140,7 @@ export const ChartFunctions: FunctionMap = {
       { name: 'Label' },
     ],
     fn: Identity,
+    category: ['chart functions'],
   },
 
   'Donut.Chart': {
@@ -132,6 +152,7 @@ export const ChartFunctions: FunctionMap = {
       { name: 'Label' },
     ],
     fn: Identity,
+    category: ['chart functions'],
   },
 
  'Scatter.Line': {
@@ -140,6 +161,7 @@ export const ChartFunctions: FunctionMap = {
       { name: 'ChartTitle' },
     ],
     fn: Identity,
+    category: ['chart functions'],
   },
 
   'Scatter.Plot': {
@@ -148,6 +170,7 @@ export const ChartFunctions: FunctionMap = {
       { name: 'ChartTitle' },
     ],
     fn: Identity,
+    category: ['chart functions'],
   },
 
  'Column.Chart': {
@@ -157,6 +180,7 @@ export const ChartFunctions: FunctionMap = {
       { name: 'Chart Title' },
     ],
     fn: Identity,
+    category: ['chart functions'],
   },
 
   'Bubble.Chart': {
@@ -165,6 +189,16 @@ export const ChartFunctions: FunctionMap = {
       { name: 'Chart Title' },
     ],
     fn: Identity,
+    category: ['chart functions'],
+  },
+
+  'Box.Plot': {
+    arguments: [
+      { name: 'Data', metadata: true, },
+      { name: 'Chart Title' },
+    ],
+    fn: Identity,
+    category: ['chart functions'],
   },
 
 };

package/treb-charts/src/chart-types.ts

@@ -199,6 +199,28 @@ export interface LineBaseData extends ChartDataBaseType {
   smooth?: boolean;
 }
 
+export interface BoxPlotData extends ChartDataBaseType {
+  type: 'box';
+  series: SeriesType[];
+  x_labels?: string[];
+  series_names?: string[];
+  y_labels?: string[];
+  scale: RangeScale;
+  max_n: number,
+
+  data: {
+    data: number[], 
+    quartiles: [number, number, number], 
+    whiskers: [number, number],
+    iqr: number,
+    n: number, 
+    min: number, 
+    max: number,
+    mean: number,
+  }[];
+
+}
+
 export interface LineData extends LineBaseData {
   type: 'line';
 }
@@ -253,6 +275,7 @@ export type ChartData
   | ColumnData
   | BarData
   | BubbleChartData
+  | BoxPlotData
   ;
 
 export enum LegendLayout {