Formula helpers and named expressions (part 2)

src/CellValue.ts

@@ -1,8 +1,44 @@
-import {CellError, ErrorType, InternalCellValue, NoErrorCellValue} from './Cell'
+import {CellError, ErrorType, InternalCellValue, NoErrorCellValue, simpleCellAddress, SimpleCellAddress} from './Cell'
+import {CellValueChange} from './ContentChanges'
 import {Config} from './Config'
+import {NamedExpressions} from './NamedExpressions'
 
 export type CellValue = NoErrorCellValue | DetailedCellError
 
+export type ExportedChange = ExportedCellChange | ExportedNamedExpressionChange
+
+export class ExportedCellChange {
+  constructor(
+    public readonly address: SimpleCellAddress,
+    public readonly newValue: CellValue,
+  ) {
+  }
+
+  public get col() {
+    return this.address.col
+  }
+
+  public get row() {
+    return this.address.row
+  }
+
+  public get sheet() {
+    return this.address.sheet
+  }
+
+  public get value() {
+    return this.newValue
+  }
+}
+
+export class ExportedNamedExpressionChange {
+  constructor(
+    public readonly name: string,
+    public readonly newValue: CellValue,
+  ) {
+  }
+}
+
 export class DetailedCellError {
   constructor(
     public readonly error: CellError,
@@ -19,13 +55,28 @@ export class DetailedCellError {
   }
 }
 
-export class CellValueExporter {
+export class Exporter {
   constructor(
     private readonly config: Config,
+    private readonly namedExpressions: NamedExpressions,
   ) {
   }
 
-  public export(value: InternalCellValue): CellValue {
+  public exportChange(change: CellValueChange): ExportedChange {
+    if (change.sheet === NamedExpressions.SHEET_FOR_WORKBOOK_EXPRESSIONS) {
+      return new ExportedNamedExpressionChange(
+        this.namedExpressions.fetchNameForNamedExpressionRow(change.row),
+        this.exportValue(change.value),
+      )
+    } else {
+      return new ExportedCellChange(
+        simpleCellAddress(change.sheet, change.col, change.row),
+        this.exportValue(change.value),
+      )
+    }
+  }
+
+  public exportValue(value: InternalCellValue): CellValue {
     if (this.config.smartRounding && typeof value == 'number' && !Number.isInteger(value)) {
       return this.cellValueRounding(value)
     } else if (value instanceof CellError) {

src/ContentChanges.ts

@@ -1,5 +1,4 @@
 import {InternalCellValue, SimpleCellAddress} from './Cell'
-import {CellValueExporter} from './CellValue'
 import {Matrix} from './Matrix'
 
 export interface CellValueChange {
@@ -9,6 +8,9 @@ export interface CellValueChange {
   value: InternalCellValue,
 }
 
+export interface IChangeExporter<T> {
+  exportChange: (arg: CellValueChange) => T,
+}
 export type ChangeList = CellValueChange[]
 
 export class ContentChanges {
@@ -38,15 +40,10 @@ export class ContentChanges {
     this.changes.push(...change)
   }
 
-  public exportChanges(exporter: CellValueExporter): ChangeList {
-    const ret: ChangeList = []
+  public exportChanges<T>(exporter: IChangeExporter<T>): T[] {
+    const ret: T[] = []
     this.changes.forEach((e, i) => {
-      ret[i] = {
-        sheet: this.changes[i].sheet,
-        col: this.changes[i].col,
-        row: this.changes[i].row,
-        value: exporter.export(this.changes[i].value),
-      }
+      ret[i] = exporter.exportChange(this.changes[i])
     })
     return ret
   }

src/Evaluator.ts

@@ -1,8 +1,11 @@
 import {ContentChanges} from './ContentChanges'
+import {InternalCellValue, SimpleCellAddress} from './Cell'
+import {Ast} from './parser'
 import {Vertex} from './DependencyGraph'
 
 export interface Evaluator {
   run(): void,
   partialRun(vertices: Vertex[]): ContentChanges,
+  runAndForget(ast: Ast, address: SimpleCellAddress): InternalCellValue,
   destroy(): void,
 }