@odoo/o-spreadsheet 14.0.1 → 14.0.2

package/src/plugins/edition.ts

@@ -1,157 +0,0 @@
-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

@@ -1,428 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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] || [];
-    }
-  }
-}