@odoo/o-spreadsheet 14.0.0 → 14.0.1

package/src/plugins/edition.ts

@@ -0,0 +1,157 @@
+import { BasePlugin } from "../base_plugin";
+import { tokenize } from "../formulas/index";
+import { toCartesian, toXC } from "../helpers/index";
+import { Mode } from "../model";
+import { Command, LAYERS } from "../types/index";
+
+export type EditionMode = "editing" | "selecting" | "inactive";
+
+export class EditionPlugin extends BasePlugin {
+  static layers = [LAYERS.Highlights];
+  static getters = ["getEditionMode", "getCurrentContent", "getEditionSheet"];
+  static modes: Mode[] = ["normal", "readonly"];
+
+  private col: number = 0;
+  private row: number = 0;
+  private mode: EditionMode = "inactive";
+  private sheet: string = "";
+  private currentContent: string = "";
+
+  // ---------------------------------------------------------------------------
+  // Command Handling
+  // ---------------------------------------------------------------------------
+
+  beforeHandle(cmd: Command) {
+    switch (cmd.type) {
+      case "ACTIVATE_SHEET":
+        if (this.mode !== "selecting") {
+          this.stopEdition();
+        }
+        break;
+    }
+  }
+
+  handle(cmd: Command) {
+    switch (cmd.type) {
+      case "START_COMPOSER_SELECTION":
+        this.mode = "selecting";
+        this.dispatch("SET_SELECTION", {
+          zones: this.getters.getSelectedZones(),
+          anchor: this.getters.getPosition(),
+        });
+        break;
+      case "STOP_COMPOSER_SELECTION":
+        if (this.mode === "selecting") {
+          this.mode = "editing";
+        }
+        break;
+      case "START_EDITION":
+        this.startEdition(cmd.text);
+        break;
+      case "STOP_EDITION":
+        if (cmd.cancel) {
+          this.cancelEdition();
+        } else {
+          this.stopEdition();
+        }
+        break;
+      case "SET_CURRENT_CONTENT":
+        this.currentContent = cmd.content;
+        break;
+      case "SELECT_CELL":
+      case "MOVE_POSITION":
+        if (this.mode === "editing") {
+          this.stopEdition();
+        }
+        break;
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Getters
+  // ---------------------------------------------------------------------------
+
+  getEditionMode(): EditionMode {
+    return this.mode;
+  }
+
+  getCurrentContent(): string {
+    return this.currentContent;
+  }
+
+  getEditionSheet(): string {
+    return this.sheet;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Misc
+  // ---------------------------------------------------------------------------
+
+  private startEdition(str?: string) {
+    if (!str) {
+      const cell = this.getters.getActiveCell();
+      str = cell ? cell.content || "" : "";
+    }
+    this.mode = "editing";
+    this.currentContent = str || "";
+    this.dispatch("REMOVE_ALL_HIGHLIGHTS");
+    const [col, row] = this.getters.getPosition();
+    this.col = col;
+    this.row = row;
+    this.sheet = this.getters.getActiveSheet();
+  }
+
+  private stopEdition() {
+    if (this.mode !== "inactive") {
+      this.cancelEdition();
+      let xc = toXC(this.col, this.row);
+      const { mergeCellMap, merges, cells } = this.getters
+        .getSheets()
+        .find((sheet) => sheet.id === this.sheet)!;
+      if (xc in mergeCellMap) {
+        const mergeId = mergeCellMap[xc];
+        xc = merges[mergeId].topLeft;
+      }
+      let content = this.currentContent;
+      this.currentContent = "";
+      const cell = cells[xc];
+      const didChange = cell ? cell.content !== content : content !== "";
+      if (!didChange) {
+        return;
+      }
+      const [col, row] = toCartesian(xc);
+      if (content) {
+        if (content.startsWith("=")) {
+          const tokens = tokenize(content);
+          const left = tokens.filter((t) => t.type === "LEFT_PAREN").length;
+          const right = tokens.filter((t) => t.type === "RIGHT_PAREN").length;
+          const missing = left - right;
+          if (missing > 0) {
+            content += new Array(missing).fill(")").join("");
+          }
+        }
+        this.dispatch("UPDATE_CELL", {
+          sheet: this.sheet,
+          col,
+          row,
+          content,
+        });
+      } else {
+        this.dispatch("UPDATE_CELL", {
+          sheet: this.sheet,
+          content: "",
+          col,
+          row,
+        });
+      }
+      if (this.getters.getActiveSheet() !== this.sheet) {
+        this.dispatch("ACTIVATE_SHEET", { from: this.getters.getActiveSheet(), to: this.sheet });
+      }
+    }
+  }
+
+  private cancelEdition() {
+    this.mode = "inactive";
+    this.dispatch("REMOVE_ALL_HIGHLIGHTS");
+  }
+}

package/src/plugins/evaluation.ts

@@ -0,0 +1,428 @@
+import { BasePlugin } from "../base_plugin";
+import { compile, normalize } from "../formulas/index";
+import { functionRegistry } from "../functions/index";
+import { mapCellsInZone, toCartesian, toXC, toZone } from "../helpers/index";
+import { WHistory } from "../history";
+import { Mode, ModelConfig } from "../model";
+import { _lt } from "../translation";
+import {
+  Cell,
+  Command,
+  CommandDispatcher,
+  EnsureRange,
+  EvalContext,
+  Getters,
+  NormalizedFormula,
+  ReferenceDenormalizer,
+  UID,
+  Workbook,
+} from "../types";
+
+function* makeObjectIterator(obj: Object) {
+  for (let i in obj) {
+    yield obj[i];
+  }
+}
+
+function* makeSetIterator(set: Set<any>) {
+  for (let elem of set) {
+    yield elem;
+  }
+}
+
+const functionMap = functionRegistry.mapping;
+
+type FormulaParameters = [ReferenceDenormalizer, EnsureRange, EvalContext];
+
+export const LOADING = "Loading...";
+
+export class EvaluationPlugin extends BasePlugin {
+  static getters = ["evaluateFormula", "isIdle"];
+  static modes: Mode[] = ["normal", "readonly"];
+
+  private isUptodate: Set<string> = new Set();
+  private loadingCells: number = 0;
+  private isStarted: boolean = false;
+  private evalContext: EvalContext;
+
+  /**
+   * For all cells that are being currently computed (asynchronously).
+   *
+   * For example: =Wait(3)
+   */
+  private PENDING: Set<Cell> = new Set();
+
+  /**
+   * For all cells that are NOT being currently computed, but depend on another
+   * asynchronous computation.
+   *
+   * For example: A2 is in WAITING (initially) and A1 in PENDING
+   *   A1: =Wait(3)
+   *   A2: =A1
+   */
+  private WAITING: { [key: string]: Set<Cell> } = {};
+
+  /**
+   * For all cells that have been async computed.
+   *
+   * For example:
+   *  A1: =Wait(3)
+   *  A2: =A1
+   *
+   * When A1 is computed, A1 is moved in COMPUTED
+   */
+  private COMPUTED: Set<Cell> = new Set();
+
+  constructor(
+    workbook: Workbook,
+    getters: Getters,
+    history: WHistory,
+    dispatch: CommandDispatcher["dispatch"],
+    config: ModelConfig
+  ) {
+    super(workbook, getters, history, dispatch, config);
+    this.evalContext = config.evalContext;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Command Handling
+  // ---------------------------------------------------------------------------
+
+  handle(cmd: Command) {
+    switch (cmd.type) {
+      case "START":
+        this.evaluate();
+        break;
+      case "UPDATE_CELL":
+        if ("content" in cmd) {
+          this.isUptodate.clear();
+        }
+        break;
+      case "EVALUATE_CELLS":
+        if (cmd.onlyWaiting) {
+          for (const sheetId in this.WAITING) {
+            const cells = new Set(this.WAITING[sheetId]);
+            this.WAITING[sheetId].clear();
+            this.evaluateCells(makeSetIterator(cells), sheetId);
+          }
+        } else {
+          for (const sheetId in this.WAITING) {
+            delete this.WAITING[sheetId];
+          }
+          this.evaluate();
+        }
+        this.isUptodate.add(this.workbook.activeSheet.id);
+        break;
+      case "UNDO":
+      case "REDO":
+        this.isUptodate.clear();
+        break;
+    }
+  }
+
+  finalize() {
+    if (!this.isUptodate.has(this.workbook.activeSheet.id)) {
+      this.evaluate();
+      this.isUptodate.add(this.workbook.activeSheet.id);
+    }
+    if (this.loadingCells > 0) {
+      this.startScheduler();
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Getters
+  // ---------------------------------------------------------------------------
+
+  evaluateFormula(formula: string, sheet: UID = this.workbook.activeSheet.id): any {
+    let formulaString: NormalizedFormula = normalize(formula);
+
+    const compiledFormula = compile(formulaString);
+    const params = this.getFormulaParameters(() => {});
+    return compiledFormula(formulaString.dependencies, sheet, ...params);
+  }
+
+  isIdle() {
+    return this.loadingCells === 0;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Scheduler
+  // ---------------------------------------------------------------------------
+
+  private startScheduler() {
+    if (!this.isStarted) {
+      this.isStarted = true;
+      let current = this.loadingCells;
+      const recomputeCells = () => {
+        if (this.loadingCells !== current) {
+          this.dispatch("EVALUATE_CELLS", { onlyWaiting: true });
+          current = this.loadingCells;
+          if (current === 0) {
+            this.isStarted = false;
+          }
+        }
+        if (current > 0) {
+          window.setTimeout(recomputeCells, 15);
+        }
+      };
+      window.setTimeout(recomputeCells, 5);
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Evaluator
+  // ---------------------------------------------------------------------------
+
+  private evaluate() {
+    this.COMPUTED.clear();
+    this.evaluateCells(
+      makeObjectIterator(this.workbook.activeSheet.cells),
+      this.workbook.activeSheet.id
+    );
+  }
+
+  private evaluateCells(cells: Generator<Cell>, sheetId: string) {
+    const self = this;
+    const { COMPUTED, PENDING, WAITING } = this;
+    const params = this.getFormulaParameters(computeValue);
+    const visited: { [sheetId: string]: { [xc: string]: boolean | null } } = {};
+
+    const _cells = [...cells];
+
+    for (let cell of _cells) {
+      // Do not reset error when it's during the compilation
+      if (cell.value !== "#BAD_EXPR") {
+        cell.error = undefined;
+      }
+    }
+
+    for (let cell of _cells) {
+      computeValue(cell, sheetId);
+    }
+
+    function handleError(e: Error | any, currentCell: Cell, currentSheetId: string) {
+      if (!(e instanceof Error)) {
+        e = new Error(e);
+      }
+      if (PENDING.has(currentCell)) {
+        PENDING.delete(currentCell);
+        self.loadingCells--;
+      }
+      if (e.message === "not ready") {
+        if (!WAITING[currentSheetId]) {
+          WAITING[currentSheetId] = new Set<Cell>();
+        }
+        WAITING[currentSheetId].add(currentCell);
+        currentCell.pending = true;
+        currentCell.value = LOADING;
+      } else if (!currentCell.error) {
+        currentCell.value = "#ERROR";
+        const __lastFnCalled = params[2].__lastFnCalled || "";
+        currentCell.error = e.message.replace("[[FUNCTION_NAME]]", __lastFnCalled);
+      }
+    }
+
+    function computeValue(cell: Cell, sheetId: string) {
+      if (cell.type !== "formula" || !cell.formula) {
+        return;
+      }
+      const xc = cell.xc;
+      visited[sheetId] = visited[sheetId] || {};
+      if (xc in visited[sheetId]) {
+        if (visited[sheetId][xc] === null) {
+          cell.value = "#CYCLE";
+          cell.error = _lt("Circular reference");
+        }
+        return;
+      }
+      if (COMPUTED.has(cell) || PENDING.has(cell)) {
+        return;
+      }
+      visited[sheetId][xc] = null;
+      cell.error = undefined;
+      try {
+        params[2].__originCellXC = xc;
+        // todo: move formatting in grid and formatters.js
+        if (cell.formula.compiledFormula.async) {
+          cell.value = LOADING;
+          cell.pending = true;
+          PENDING.add(cell);
+
+          cell.formula
+            .compiledFormula(cell.formula.dependencies, sheetId, ...params)
+            .then((val) => {
+              cell.value = val;
+              self.loadingCells--;
+              if (PENDING.has(cell)) {
+                PENDING.delete(cell);
+                cell.pending = false;
+                COMPUTED.add(cell);
+              }
+            })
+            .catch((e: Error) => handleError(e, cell, sheetId));
+          self.loadingCells++;
+        } else {
+          cell.value = cell.formula.compiledFormula(cell.formula.dependencies, sheetId, ...params);
+          cell.pending = false;
+        }
+        if (Array.isArray(cell.value)) {
+          // if a value returns an array (like =A1:A3)
+          throw new Error(_lt("This formula depends on invalid values"));
+        } else {
+          cell.error = undefined;
+        }
+      } catch (e) {
+        handleError(e, cell, sheetId);
+      }
+      visited[sheetId][xc] = true;
+    }
+  }
+
+  /**
+   * Return all functions necessary to properly evaluate a formula:
+   * - a refFn function to read any reference, cell or range of a normalized formula
+   * - a range function to convert any reference to a proper value array
+   * - an evaluation context
+   */
+  private getFormulaParameters(computeValue: Function): FormulaParameters {
+    const evalContext = Object.assign(Object.create(functionMap), this.evalContext, {
+      getters: this.getters,
+    });
+    const sheets = this.workbook.sheets;
+    const PENDING = this.PENDING;
+    function readCell(xc: string, sheetId: UID): any {
+      let cell;
+      const s = sheets[sheetId];
+      if (s) {
+        cell = s.cells[xc.toUpperCase().replace(/\$/g, "")];
+      } else {
+        throw new Error(_lt("Invalid sheet name"));
+      }
+      if (!cell || cell.content === "") {
+        return null;
+      }
+      const value = getCellValue(cell, sheetId);
+      if (value === LOADING) {
+        throw new Error("not ready");
+      }
+      return value;
+    }
+
+    function getCellValue(cell: Cell, sheetId: UID): any {
+      if (cell.formula && cell.formula.compiledFormula.async && cell.error && !PENDING.has(cell)) {
+        throw new Error(_lt("This formula depends on invalid values"));
+      }
+      computeValue(cell, sheetId);
+      if (cell.error) {
+        throw new Error(_lt("This formula depends on invalid values"));
+      }
+      return cell.value;
+    }
+
+    /**
+     * Return a range of values. It is a list of col values.
+     *
+     * Note that each col is possibly sparse: it only contain the values of cells
+     * that are actually present in the grid.
+     */
+    function _range(v1: string, v2: string, sheetId: UID): any[][] {
+      const sheet = sheets[sheetId];
+      let [left, top] = toCartesian(v1);
+      let [right, bottom] = toCartesian(v2);
+      right = Math.min(right, sheet.colNumber - 1);
+      bottom = Math.min(bottom, sheet.rowNumber - 1);
+
+      if (left > right) {
+        const tmp = left;
+        left = right;
+        right = tmp;
+      }
+      if (top > bottom) {
+        const tmp = top;
+        top = bottom;
+        bottom = tmp;
+      }
+
+      const zone = { left, top, right, bottom };
+      const result = mapCellsInZone(zone, sheet, (cell) => getCellValue(cell, sheetId));
+      for (const col of result) {
+        for (const value of col) {
+          if (value === LOADING) {
+            throw new Error("not ready");
+          }
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Returns the value of the cell(s) used in reference
+     *
+     * @param position the index in the references array
+     * @param references all the references used in the current formula
+     * @param sheetId the sheet that is currently being evaluated, if a reference does not
+     *        include a sheet, it is the id of the sheet of the reference to be used
+     */
+    function refFn(
+      position: number,
+      references: string[],
+      sheetId: UID,
+      functionName: string,
+      paramNumber: number
+    ): any | any[][] {
+      const referenceText = references[position];
+
+      const [reference, sheetName] = referenceText.split("!").reverse();
+      const referenceSheetId = sheetName
+        ? evalContext.getters.getSheetIdByName(sheetName)
+        : sheetId;
+
+      const zone = toZone(referenceText);
+
+      if (zone.top > zone.bottom || zone.left > zone.right) {
+        throw new Error(
+          _lt("invalid range %s:%s", toXC(zone.left, zone.top), toXC(zone.right, zone.bottom))
+        );
+      }
+
+      // if the formula definition could have accepted a range, we would pass through the _range function and not here
+      if (zone.bottom !== zone.top || zone.left !== zone.right) {
+        throw new Error(
+          _lt(
+            "Function %s expects the parameter %s to be a single value or a single cell reference, not a range.",
+            functionName.toString(),
+            paramNumber.toString()
+          )
+        );
+      }
+      //it's a cell
+      return readCell(reference, referenceSheetId);
+    }
+
+    /**
+     * Return the values of the cell(s) used in reference, but always in the format of a range even
+     * if a single cell is referenced. This is useful for the formulas that describe parameters as
+     * range<number> etc.
+     *
+     * the parameters are the same as refFn, except that these parameters cannot be Meta
+     */
+    function range(position: number, references: string[], sheetId: UID): any[][] {
+      const referenceText = references[position];
+      const [reference, sheetName] = referenceText.split("!").reverse();
+      const referenceSheetId = sheetName
+        ? evalContext.getters.getSheetIdByName(sheetName)
+        : sheetId;
+
+      if (references[position] && !references[position].includes(":")) {
+        //it's a cell reference, but it must be treated as a range
+        return _range(reference, reference, referenceSheetId);
+      } else {
+        const [left, right] = reference.split(":");
+        return _range(left, right, referenceSheetId);
+      }
+    }
+
+    return [refFn, range, evalContext];
+  }
+}

package/src/plugins/figures.ts

@@ -0,0 +1,123 @@
+import { BasePlugin } from "../base_plugin";
+import { Command, Figure, Viewport, WorkbookData } from "../types/index";
+
+export class FigurePlugin extends BasePlugin {
+  static getters = ["getFigures", "getSelectedFigureId", "getFigure"];
+
+  private selectedFigureId: string | null = null;
+
+  private figures: { [figId: string]: Figure<any> } = {};
+  private sheetFigures: { [sheetId: string]: Figure<any>[] } = {};
+
+  // ---------------------------------------------------------------------------
+  // Command Handling
+  // ---------------------------------------------------------------------------
+  handle(cmd: Command) {
+    switch (cmd.type) {
+      case "DELETE_SHEET":
+        this.deleteSheet(cmd.sheet);
+        break;
+      case "CREATE_FIGURE":
+        this.history.updateLocalState(["figures", cmd.figure.id], cmd.figure);
+        const sheetFigures = (this.sheetFigures[cmd.sheet] || []).slice();
+        sheetFigures.push(cmd.figure);
+        this.history.updateLocalState(["sheetFigures", cmd.sheet], sheetFigures);
+        break;
+      case "UPDATE_FIGURE":
+        if (cmd.x !== undefined) {
+          this.history.updateLocalState(["figures", cmd.id, "x"], Math.max(cmd.x, 0));
+        }
+        if (cmd.y !== undefined) {
+          this.history.updateLocalState(["figures", cmd.id, "y"], Math.max(cmd.y, 0));
+        }
+        if (cmd.width !== undefined) {
+          this.history.updateLocalState(["figures", cmd.id, "width"], cmd.width);
+        }
+        if (cmd.height !== undefined) {
+          this.history.updateLocalState(["figures", cmd.id, "height"], cmd.height);
+        }
+        if (cmd.data !== undefined) {
+          this.history.updateLocalState(["figures", cmd.id, "data"], cmd.data);
+        }
+        break;
+      case "SELECT_FIGURE":
+        this.selectedFigureId = cmd.id;
+        break;
+      case "DELETE_FIGURE":
+        this.history.updateLocalState(["figures", cmd.id], undefined);
+        for (let s in this.sheetFigures) {
+          let deletedFigureIndex = this.sheetFigures[s].findIndex((f) => f.id === cmd.id);
+          if (deletedFigureIndex > -1) {
+            const copy = this.sheetFigures[s].slice();
+            copy.splice(deletedFigureIndex, 1);
+            this.history.updateLocalState(["sheetFigures", s], copy);
+            this.selectedFigureId = null;
+          }
+        }
+        break;
+      // some commands should not remove the current selection
+      case "EVALUATE_CELLS":
+        break;
+      default:
+        this.selectedFigureId = null;
+    }
+  }
+
+  deleteSheet(sheet: string) {
+    for (let figure of this.sheetFigures[sheet] || []) {
+      this.history.updateLocalState(["figures", figure.id], undefined);
+    }
+    const sheetFigures = Object.assign({}, this.sheetFigures);
+    delete sheetFigures[sheet];
+    this.history.updateLocalState(["sheetFigures"], sheetFigures);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Getters
+  // ---------------------------------------------------------------------------
+
+  getFigures(viewport: Viewport): Figure<any>[] {
+    const result: Figure<any>[] = [];
+    const figures = this.sheetFigures[this.workbook.activeSheet.id] || [];
+    const { offsetX, offsetY, width, height } = viewport;
+    for (let figure of figures) {
+      if (figure.x >= offsetX + width || figure.x + figure.width <= offsetX) {
+        continue;
+      }
+      if (figure.y >= offsetY + height || figure.y + figure.height <= offsetY) {
+        continue;
+      }
+      result.push(figure);
+    }
+    return result;
+  }
+
+  getSelectedFigureId(): string | null {
+    return this.selectedFigureId;
+  }
+
+  getFigure<T>(figureId: string): Figure<T> {
+    return this.figures[figureId];
+  }
+
+  // ---------------------------------------------------------------------------
+  // Import/Export
+  // ---------------------------------------------------------------------------
+
+  import(data: WorkbookData) {
+    for (let sheet of data.sheets) {
+      const figList: Figure<any>[] = [];
+      for (let f of sheet.figures) {
+        this.figures[f.id] = f;
+        figList.push(f);
+      }
+      this.sheetFigures[sheet.id] = figList;
+    }
+  }
+
+  export(data: WorkbookData) {
+    for (let sheetData of data.sheets) {
+      sheetData.figures = this.sheetFigures[sheetData.id] || [];
+    }
+  }
+}