@trebco/treb 37.0.0 → 37.0.1

package/build/treb-calculator/src/dag/array-vertex.js

@@ -0,0 +1,156 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with TREB. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Copyright 2022-2026 trebco, llc.
+ * info@treb.app
+ *
+ */
+import { SpreadsheetVertexBase } from './spreadsheet_vertex_base';
+import { Color } from './vertex';
+/**
+ * this is a new cut at array vertices. unlike the old version, we are not
+ * trying to reduce the number of vertices (and in fact we won't). this is
+ * to handle the case of unbounded arrays (full rows or columns).
+ *
+ * standard behavior with an array is to create all vertices when the reference
+ * is created (this is wasteful, but works). this does _not_ work for unbounded
+ * arrays because we may add rows/columns later which will expand arrays.
+ *
+ * so this class is an intermediate vertex that sits between the dependent edge
+ * and all the members of the array. if a new vertex is created later, we check
+ * existing arrays to see if anyone will need to add it.
+ *
+ * the more arrays you have, the more expensive these checks are (we could
+ * probably optimize this a bit), but it only happens at create time so
+ * potentially it's not too bad -- only on initial create and when manually
+ * modifying the spreadsheet.
+ *
+ * [FIXME: that initial create step could definitely be optimized to limit checks]
+ *
+ */
+export class ArrayVertex extends SpreadsheetVertexBase {
+    static type = 'array-vertex';
+    /**
+     * this is the list of currently used array vertices. it will get cleaned
+     * up when a vertex is no longer used (via the instance RemoveDependent
+     * overload) and when the graph is reset (via the static Clear method).
+     *
+     * we could theoretically optimize this store, which might be useful if
+     * we start using a lot of these: split by sheet ID, sort in start/end order,
+     * and so on.
+     */
+    static list = [];
+    type = ArrayVertex.type; // for type guard
+    /** the target area */
+    area;
+    /**
+     * factory/lookup method: creates a vertex if it does not exist, or
+     * returns existing vertex. returns the vertex and a flag indicating
+     * if this was created new (true) or not (false).
+     */
+    static GetVertex(area) {
+        for (const entry of this.list) {
+            if ((entry.area.start.sheet_id === area.start.sheet_id) && entry.area.Equals(area)) {
+                return [entry, false];
+            }
+        }
+        return [new ArrayVertex(area), true];
+    }
+    /**
+     * this seems sloppy, does this clean up properly?
+     */
+    static Clear() {
+        this.list = [];
+    }
+    /**
+     * returns a list of arrays that contain this address
+     */
+    static GetContainingArrays(address) {
+        const list = [];
+        for (const entry of this.list) {
+            if ((entry.area.start.sheet_id === address.sheet_id) && entry.area.Contains(address)) {
+                list.push(entry);
+            }
+        }
+        return list;
+    }
+    /**
+     * if any arrays contain this address, add edges
+     */
+    static CreateImplicitEdges(vertex, address) {
+        // console.info('av2 create implicit edges:', address.row, address.column);
+        for (const entry of this.list) {
+            if ((entry.area.start.sheet_id === address.sheet_id) && entry.area.Contains(address)) {
+                // console.info("add to", entry.area.spreadsheet_label);
+                entry.DependsOn(vertex);
+            }
+        }
+    }
+    /**
+     * constructor adds the vertex to the internal list (static to this class).
+     *
+     * UPDATE: use the factory method, which can check if a reference to this
+     * area already exists.
+     */
+    constructor(range) {
+        super();
+        this.area = range.Clone();
+        ArrayVertex.list.push(this);
+    }
+    /**
+     * override for RemoveDependent. if there are no more dependents, it will
+     * be removed from our internal list (and hopefully GCd, but check).
+     */
+    RemoveDependent(edge) {
+        super.RemoveDependent(edge);
+        if (!this.edges_out.size) {
+            // console.info('removing dead array vertex');
+            this.Reset();
+            ArrayVertex.list = ArrayVertex.list.filter(test => test !== this);
+        }
+    }
+    Calculate(graph) {
+        // this is copied from SpreadsheetVertex, just removing the 
+        // actual calculation (because we have no output). 
+        if (!this.dirty) {
+            return;
+        }
+        if (this.color === Color.white && this.LoopCheck()) {
+            // console.info('LC', this);
+            this.dirty = false;
+            if (this.edges_in.size) {
+                // intuitively this seems like a good idea but I'm not sure
+                // that it is actually necessary (TODO: check)
+                for (const edge of this.edges_out) {
+                    edge.Calculate(graph);
+                }
+                return;
+            }
+        }
+        for (const edge of this.edges_in) {
+            if (edge.dirty) {
+                return;
+            }
+        }
+        // console.info('setting dirty -> false');
+        this.dirty = false;
+        for (const edge of this.edges_out) {
+            edge.Calculate(graph);
+        }
+    }
+}
+// (self as any).AV2 = ArrayVertex2;
+//# sourceMappingURL=array-vertex.js.map

package/build/treb-calculator/src/dag/array-vertex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-vertex.js","sourceRoot":"","sources":["../../../../treb-calculator/src/dag/array-vertex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAuB,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGvF,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,WAAY,SAAQ,qBAAqB;IAE7C,MAAM,CAAC,IAAI,GAAG,cAAc,CAAC;IAEpC;;;;;;;;OAQG;IACK,MAAM,CAAC,IAAI,GAAkB,EAAE,CAAC;IAEjC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,iBAAiB;IAEjD,sBAAsB;IACf,IAAI,CAAO;IAElB;;;;OAIG;IACI,MAAM,CAAC,SAAS,CAAC,IAAU;QAChC,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YAC9B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;gBACnF,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;QACD,OAAO,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;IACvC,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,KAAK;QACjB,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;IACjB,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,mBAAmB,CAAC,OAAsB;QACtD,MAAM,IAAI,GAAkB,EAAE,CAAC;QAC/B,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YAC9B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,KAAK,OAAO,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBACrF,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,mBAAmB,CAAC,MAAc,EAAE,OAAsB;QACtE,2EAA2E;QAC3E,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YAC9B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,KAAK,OAAO,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBACrF,wDAAwD;gBACxD,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,YAAoB,KAAW;QAC7B,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;QAC1B,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACI,eAAe,CAAC,IAAY;QACjC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;YACzB,8CAA8C;YAC9C,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,WAAW,CAAC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAEM,SAAS,CAAC,KAAqB;QAEpC,4DAA4D;QAC5D,mDAAmD;QAEnD,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YAEnD,4BAA4B;YAC5B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;YAEnB,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;gBAEvB,2DAA2D;gBAC3D,8CAA8C;gBAE9C,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,SAAS,EAAC,CAAC;oBAChC,IAA0B,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;gBAC/C,CAAC;gBAED,OAAO;YAET,CAAC;QACH,CAAC;QAED,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACjC,IAAK,IAA8B,CAAC,KAAK,EAAE,CAAC;gBAC1C,OAAO;YACT,CAAC;QACH,CAAC;QAED,0CAA0C;QAC1C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,SAAS,EAAC,CAAC;YAChC,IAA0B,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC/C,CAAC;IAEH,CAAC;;AAIH,oCAAoC"}

package/build/treb-calculator/src/dag/calculation_leaf_vertex.d.ts

@@ -0,0 +1,48 @@
+import type { GraphCallbacks } from './spreadsheet_vertex_base';
+import { SpreadsheetVertex } from './spreadsheet_vertex';
+import { Color } from './vertex';
+/**
+ * adding a new leaf vertex type that actually does a calculation;
+ * but it has no spreadsheet context (address) and by definition it
+ * has no dependendents.
+ *
+ * this is intended for managing conditional formats, if they have
+ * an expression. we only want to calculate these when necessary
+ * (i.e. dependencies have updated, or they are volatile).
+ *
+ */
+export declare class CalculationLeafVertex extends SpreadsheetVertex {
+    static type: string;
+    type: string;
+    address: {
+        row: number;
+        column: number;
+    };
+    /**
+     * this type is currently only used for conditional formatting.
+     * but that might change in the future. I want to identify what
+     * it's used for so we can selectively prune them when necessary.
+     */
+    use?: string;
+    /**
+     * flag, to reduce unecessary application. work in progress. this
+     * indicates that we reached the calculation step. that means either
+     * (1) dependencies changed, or (2) we were marked dirty in some global
+     * operation, probably a full-recalc.
+     *
+     * (2) is a waste but we're still going to save some cycles here. if you
+     * want you could add a state check like the other leaf vertex.
+     */
+    updated: boolean;
+    /**
+     * leaf vertex defaults to black (i.e. tested) because leaf nodes cannot have
+     * outbound edges. it is still possible to change this, because it's a property
+     * and we can't override the set accessor, but making it an accessor in the
+     * superclass just for this purpose is not worthwhile since regular vertices
+     * should vastly outnumber leaves.
+     */
+    color: Color;
+    /** overrides calculate function */
+    Calculate(graph: GraphCallbacks): void;
+    AddDependent(): void;
+}

package/build/treb-calculator/src/dag/calculation_leaf_vertex.js

@@ -0,0 +1,84 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with TREB. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Copyright 2022-2026 trebco, llc.
+ * info@treb.app
+ *
+ */
+import { SpreadsheetVertex } from './spreadsheet_vertex';
+import { Color } from './vertex';
+/**
+ * adding a new leaf vertex type that actually does a calculation;
+ * but it has no spreadsheet context (address) and by definition it
+ * has no dependendents.
+ *
+ * this is intended for managing conditional formats, if they have
+ * an expression. we only want to calculate these when necessary
+ * (i.e. dependencies have updated, or they are volatile).
+ *
+ */
+export class CalculationLeafVertex extends SpreadsheetVertex {
+    static type = 'calculation-leaf-vertex';
+    type = CalculationLeafVertex.type; // for type guard
+    address = { row: -1, column: -1 }; // fake address
+    /**
+     * this type is currently only used for conditional formatting.
+     * but that might change in the future. I want to identify what
+     * it's used for so we can selectively prune them when necessary.
+     */
+    use;
+    /**
+     * flag, to reduce unecessary application. work in progress. this
+     * indicates that we reached the calculation step. that means either
+     * (1) dependencies changed, or (2) we were marked dirty in some global
+     * operation, probably a full-recalc.
+     *
+     * (2) is a waste but we're still going to save some cycles here. if you
+     * want you could add a state check like the other leaf vertex.
+     */
+    updated = false;
+    /**
+     * leaf vertex defaults to black (i.e. tested) because leaf nodes cannot have
+     * outbound edges. it is still possible to change this, because it's a property
+     * and we can't override the set accessor, but making it an accessor in the
+     * superclass just for this purpose is not worthwhile since regular vertices
+     * should vastly outnumber leaves.
+     */
+    color = Color.black;
+    /** overrides calculate function */
+    Calculate(graph) {
+        // if we are not dirty, nothing to do
+        if (!this.dirty)
+            return;
+        // check deps
+        for (const edge of this.edges_in) {
+            if (edge.dirty) {
+                return;
+            }
+        }
+        // ...
+        const result = graph.CalculationCallback.call(graph, this);
+        this.result = result.value;
+        this.dirty = false;
+        // set flag
+        this.updated = true;
+        // we are not allowed to have edges out, so nothing to do
+    }
+    AddDependent() {
+        throw (new Error('leaf vertex cannot have dependents'));
+    }
+}
+//# sourceMappingURL=calculation_leaf_vertex.js.map

package/build/treb-calculator/src/dag/calculation_leaf_vertex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculation_leaf_vertex.js","sourceRoot":"","sources":["../../../../treb-calculator/src/dag/calculation_leaf_vertex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC;;;;;;;;;GASG;AACH,MAAM,OAAO,qBAAsB,SAAQ,iBAAiB;IAEnD,MAAM,CAAC,IAAI,GAAG,yBAAyB,CAAC;IAExC,IAAI,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC,iBAAiB;IAEpD,OAAO,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,eAAe;IAEzD;;;;OAIG;IACI,GAAG,CAAU;IAEpB;;;;;;;;OAQG;IACI,OAAO,GAAG,KAAK,CAAC;IAEvB;;;;;;OAMG;IACI,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAE3B,mCAAmC;IAC5B,SAAS,CAAC,KAAqB;QAEpC,qCAAqC;QACrC,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO;QAExB,aAAa;QACb,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACjC,IAAK,IAA0B,CAAC,KAAK,EAAE,CAAC;gBACtC,OAAO;YACT,CAAC;QACH,CAAC;QAED,MAAM;QAEN,MAAM,MAAM,GAAG,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAE3D,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC;QAC3B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,WAAW;QAEX,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QAEpB,yDAAyD;IAE3D,CAAC;IAEM,YAAY;QACjB,MAAK,CAAC,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC,CAAC;IACzD,CAAC"}

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

@@ -0,0 +1,134 @@
+import type { Vertex } from './vertex';
+import { SpreadsheetVertex } from './spreadsheet_vertex';
+import type { SpreadsheetVertexBase, CalculationResult, GraphCallbacks } from './spreadsheet_vertex_base';
+import type { StateLeafVertex } from './state_leaf_vertex';
+import type { ICellAddress, IArea, UnionValue } from 'treb-base-types';
+import { Area } from 'treb-base-types';
+import type { DataModel } from 'treb-data-model';
+import { CalculationLeafVertex } from './calculation_leaf_vertex';
+export type LeafVertex = StateLeafVertex | CalculationLeafVertex;
+export type { StateLeafVertex };
+export declare enum GraphStatus {
+    OK = 0,
+    Loop = 1,
+    CalculationError = 2
+}
+/**
+ * graph is now abstract, as we are extending it with the calculator.
+ */
+export declare abstract class Graph implements GraphCallbacks {
+    /**
+     * list of vertices, indexed by address as [sheet id][column][row]
+     */
+    vertices: Array<Array<Array<SpreadsheetVertex | undefined>>>;
+    volatile_list: SpreadsheetVertexBase[];
+    calculation_list: SpreadsheetVertexBase[];
+    spill_data: {
+        area: IArea;
+        vertex: StateLeafVertex;
+    }[];
+    protected abstract readonly model: DataModel;
+    /**
+     * where is the loop in the graph (or at least the first one we found)?
+     */
+    loop_hint?: string;
+    leaf_vertices: Set<LeafVertex>;
+    /** lock down access */
+    private dirty_list;
+    /** flag set on add edge */
+    private loop_check_required;
+    IsSpreadsheetVertex(vertex: Vertex): vertex is SpreadsheetVertex;
+    /**
+     * flush the graph, calculation tree and cells reference
+     */
+    FlushTree(): void;
+    ResolveArrayHead(address: ICellAddress): ICellAddress;
+    /**
+     * iterate vertices
+     * @param area
+     */
+    IterateVertices(area: IArea, create?: boolean): Generator<SpreadsheetVertex>;
+    /** overload */
+    GetVertex(address: ICellAddress, create: true): SpreadsheetVertex;
+    /** overload */
+    GetVertex(address: ICellAddress, create?: boolean): SpreadsheetVertex | undefined;
+    /** deletes the vertex at this address. */
+    RemoveVertex(address: ICellAddress): void;
+    /** removes all edges, for rebuilding. leaves value/formula as-is. */
+    ResetVertex(address: ICellAddress): void;
+    RIBcount: number;
+    /**
+     * resets the vertex by removing inbound edges and clearing formula flag.
+     * we have an option to set dirty because they get called together
+     * frequently, saves a lookup.
+     */
+    ResetInbound(address: ICellAddress, set_dirty?: boolean, create?: boolean, remove?: boolean): void;
+    /**
+     * reset all vertices. this method is used so we can run the loop check
+     * as part of the graph calculation, instead of requiring the separate call.
+     */
+    ResetLoopState(): void;
+    /**
+     * global check returns true if there is any loop. this is more efficient
+     * than detecting loops on every call to AddEdge. uses the color algorithm
+     * from CLRS.
+     *
+     * UPDATE we switched to a stack-based check because we were hitting
+     * recursion limits, although that seemed to only happen in workers --
+     * perhaps they have different stack [in the malloc sense] sizes? in any
+     * event, I think the version below is now stable.
+     *
+     * @param force force a check, for dev/debug
+     */
+    LoopCheck(force?: boolean): boolean;
+    /**
+     * render address as string; this is for reporting loops
+     */
+    RenderAddress(address?: ICellAddress): string;
+    /**
+     * new array vertices
+     */
+    protected CompositeAddArrayEdge(u: Area, vertex: Vertex): void;
+    AddLeafVertexArrayEdge(u: Area, vertex: LeafVertex): void;
+    /**
+     * new array vertices
+     */
+    AddArrayEdge(u: Area, v: ICellAddress): void;
+    /** adds an edge from u -> v */
+    AddEdge(u: ICellAddress, v: ICellAddress): void;
+    /** removes edge from u -> v */
+    RemoveEdge(u: ICellAddress, v: ICellAddress): void;
+    /**
+     * not used? remove
+     * @deprecated
+     */
+    SetAreaDirty(area: IArea): void;
+    SetVertexDirty(vertex: SpreadsheetVertexBase): void;
+    /** sets dirty */
+    SetDirty(address: ICellAddress): void;
+    /**
+     * adds a leaf vertex to the graph. this implies that someone else is
+     * managing and maintaining these vertices: we only need references.
+     */
+    AddLeafVertex(vertex: LeafVertex): void;
+    /** removes vertex */
+    RemoveLeafVertex(vertex: LeafVertex): void;
+    /**
+     * adds an edge from u -> v where v is a leaf vertex. this doesn't use
+     * the normal semantics, and you must pass in the actual vertex instead
+     * of an address.
+     *
+     * there is no loop check (leaves are not allowed to have outbound
+     * edges).
+     */
+    AddLeafVertexEdge(u: ICellAddress, v: LeafVertex): GraphStatus;
+    /** removes edge from u -> v */
+    RemoveLeafVertexEdge(u: ICellAddress, v: LeafVertex): void;
+    InitializeGraph(): void;
+    /** runs calculation */
+    Recalculate(): void;
+    abstract CalculationCallback(vertex: SpreadsheetVertexBase): CalculationResult;
+    abstract SpreadCallback(vertex: SpreadsheetVertexBase, value: UnionValue): void;
+    abstract SpillCallback(vertex: SpreadsheetVertexBase, value: UnionValue): void;
+    protected abstract CheckVolatile(vertex: SpreadsheetVertex): boolean;
+}