@odoo/o-spreadsheet 14.0.1 → 15.0.0

package/src/plugins/core.ts

@@ -1,1502 +0,0 @@
-import { BasePlugin } from "../base_plugin";
-import { DEFAULT_CELL_HEIGHT, DEFAULT_CELL_WIDTH } from "../constants";
-import { cellReference, compile, normalize, rangeTokenize } from "../formulas/index";
-import { formatDateTime, InternalDate, parseDateTime } from "../functions/dates";
-import {
-  formatNumber,
-  formatStandardNumber,
-  getComposerSheetName,
-  getUnquotedSheetName,
-  isNumber,
-  mapCellsInZone,
-  numberToLetters,
-  parseNumber,
-  recomputeZones,
-  toCartesian,
-  toXC,
-  toZone,
-} from "../helpers/index";
-import { _lt } from "../translation";
-import {
-  CancelledReason,
-  Cell,
-  CellData,
-  Col,
-  Command,
-  CommandResult,
-  HeaderData,
-  NormalizedFormula,
-  RenameSheetCommand,
-  Row,
-  Sheet,
-  SheetData,
-  WorkbookData,
-  Zone,
-} from "../types/index";
-
-const nbspRegexp = new RegExp(String.fromCharCode(160), "g");
-const MIN_PADDING = 3;
-
-/**
- * Core Plugin
- *
- * This is the most fundamental of all plugins. It defines how to interact with
- * cell and sheet content.
- */
-export class CorePlugin extends BasePlugin {
-  static getters = [
-    "applyOffset",
-    "getColsZone",
-    "getRowsZone",
-    "getCell",
-    "getCellText",
-    "zoneToXC",
-    "getActiveSheet",
-    "getSheetName",
-    "getSheetIdByName",
-    "getSheets",
-    "getCol",
-    "getRow",
-    "getColCells",
-    "getNumberCols",
-    "getNumberRows",
-    "getGridSize",
-    "shouldShowFormulas",
-    "getRangeValues",
-    "getRangeFormattedValues",
-  ];
-
-  private sheetIds: { [name: string]: string } = {};
-  private showFormulas: boolean = false;
-
-  // ---------------------------------------------------------------------------
-  // Command Handling
-  // ---------------------------------------------------------------------------
-
-  allowDispatch(cmd: Command): CommandResult {
-    switch (cmd.type) {
-      case "REMOVE_COLUMNS":
-        return this.workbook.sheets[cmd.sheet].cols.length > cmd.columns.length
-          ? { status: "SUCCESS" }
-          : { status: "CANCELLED", reason: CancelledReason.NotEnoughColumns };
-      case "REMOVE_ROWS":
-        return this.workbook.sheets[cmd.sheet].rows.length > cmd.rows.length
-          ? { status: "SUCCESS" }
-          : { status: "CANCELLED", reason: CancelledReason.NotEnoughRows };
-      case "CREATE_SHEET":
-      case "DUPLICATE_SHEET":
-        const { visibleSheets, sheets } = this.workbook;
-        return !cmd.name || !visibleSheets.find((id) => sheets[id].name === cmd.name)
-          ? { status: "SUCCESS" }
-          : { status: "CANCELLED", reason: CancelledReason.WrongSheetName };
-      case "MOVE_SHEET":
-        const currentIndex = this.workbook.visibleSheets.findIndex((id) => id === cmd.sheet);
-        if (currentIndex === -1) {
-          return { status: "CANCELLED", reason: CancelledReason.WrongSheetName };
-        }
-        return (cmd.direction === "left" && currentIndex === 0) ||
-          (cmd.direction === "right" && currentIndex === this.workbook.visibleSheets.length - 1)
-          ? { status: "CANCELLED", reason: CancelledReason.WrongSheetMove }
-          : { status: "SUCCESS" };
-      case "RENAME_SHEET":
-        return this.isRenameAllowed(cmd);
-      case "DELETE_SHEET_CONFIRMATION":
-      case "DELETE_SHEET":
-        return this.workbook.visibleSheets.length > 1
-          ? { status: "SUCCESS" }
-          : { status: "CANCELLED", reason: CancelledReason.NotEnoughSheets };
-      default:
-        return { status: "SUCCESS" };
-    }
-  }
-
-  handle(cmd: Command) {
-    switch (cmd.type) {
-      case "ACTIVATE_SHEET":
-        this.history.updateState(["activeSheet"], this.workbook.sheets[cmd.to]);
-        break;
-      case "CREATE_SHEET":
-        const sheet = this.createSheet(
-          cmd.id,
-          cmd.name || this.generateSheetName(),
-          cmd.cols || 26,
-          cmd.rows || 100
-        );
-        this.sheetIds[this.workbook.sheets[sheet].name] = sheet;
-        if (cmd.activate) {
-          this.dispatch("ACTIVATE_SHEET", { from: this.workbook.activeSheet.id, to: sheet });
-        }
-        break;
-      case "MOVE_SHEET":
-        this.moveSheet(cmd.sheet, cmd.direction);
-        break;
-      case "RENAME_SHEET":
-        if (cmd.interactive) {
-          this.interactiveRenameSheet(cmd.sheet, _lt("Rename Sheet"));
-        } else {
-          this.renameSheet(cmd.sheet, cmd.name!);
-        }
-        break;
-      case "DUPLICATE_SHEET":
-        this.duplicateSheet(cmd.sheet, cmd.id, cmd.name);
-        break;
-      case "DELETE_SHEET_CONFIRMATION":
-        this.interactiveDeleteSheet(cmd.sheet);
-        break;
-      case "DELETE_SHEET":
-        this.deleteSheet(cmd.sheet);
-        break;
-      case "DELETE_CONTENT":
-        this.clearZones(cmd.sheet, cmd.target);
-        break;
-      case "SET_VALUE":
-        const [col, row] = toCartesian(cmd.xc);
-        this.dispatch("UPDATE_CELL", {
-          sheet: cmd.sheetId ? cmd.sheetId : this.workbook.activeSheet.id,
-          col,
-          row,
-          content: cmd.text,
-        });
-        break;
-      case "UPDATE_CELL":
-        this.updateCell(cmd.sheet, cmd.col, cmd.row, cmd);
-        break;
-      case "CLEAR_CELL":
-        this.dispatch("UPDATE_CELL", {
-          sheet: cmd.sheet,
-          col: cmd.col,
-          row: cmd.row,
-          content: "",
-          border: 0,
-          style: 0,
-          format: "",
-        });
-        break;
-      case "AUTORESIZE_COLUMNS":
-        for (let col of cmd.cols) {
-          const size = this.getColMaxWidth(col);
-          if (size !== 0) {
-            this.setColSize(cmd.sheet, col, size + 2 * MIN_PADDING);
-          }
-        }
-        break;
-      case "AUTORESIZE_ROWS":
-        for (let col of cmd.rows) {
-          const size = this.getRowMaxHeight(col);
-          if (size !== 0) {
-            this.setRowSize(cmd.sheet, col, size + 2 * MIN_PADDING);
-          }
-        }
-        break;
-      case "RESIZE_COLUMNS":
-        for (let col of cmd.cols) {
-          this.setColSize(cmd.sheet, col, cmd.size);
-        }
-        break;
-      case "RESIZE_ROWS":
-        for (let row of cmd.rows) {
-          this.setRowSize(cmd.sheet, row, cmd.size);
-        }
-        break;
-      case "REMOVE_COLUMNS":
-        this.removeColumns(cmd.sheet, cmd.columns);
-        this.history.updateState(
-          ["sheets", cmd.sheet, "colNumber"],
-          this.workbook.sheets[cmd.sheet].colNumber - cmd.columns.length
-        );
-        break;
-      case "REMOVE_ROWS":
-        this.removeRows(cmd.sheet, cmd.rows);
-        this.history.updateState(
-          ["sheets", cmd.sheet, "rowNumber"],
-          this.workbook.sheets[cmd.sheet].rowNumber - cmd.rows.length
-        );
-        break;
-      case "ADD_COLUMNS":
-        this.addColumns(cmd.sheet, cmd.column, cmd.position, cmd.quantity);
-        this.history.updateState(
-          ["activeSheet", "colNumber"],
-          this.workbook.activeSheet.colNumber + cmd.quantity
-        );
-        break;
-      case "ADD_ROWS":
-        this.addRows(cmd.sheet, cmd.row, cmd.position, cmd.quantity);
-        this.history.updateState(
-          ["activeSheet", "rowNumber"],
-          this.workbook.activeSheet.rowNumber + cmd.quantity
-        );
-        break;
-      case "SET_FORMULA_VISIBILITY":
-        this.showFormulas = cmd.show;
-        break;
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Getters
-  // ---------------------------------------------------------------------------
-
-  applyOffset(formula: string, offsetX: number, offsetY: number): string {
-    return rangeTokenize(formula)
-      .map((t) => {
-        if (t.type === "SYMBOL" && cellReference.test(t.value)) {
-          const [xcs, sheetName] = t.value.split("!").reverse();
-          const sheetId = this.getSheetIdByName(sheetName);
-          if (xcs.includes(":")) {
-            return this.updateRange(xcs, offsetX, offsetY, sheetId);
-          }
-          return this.updateReference(xcs, offsetX, offsetY, sheetId, true, false);
-        }
-        return t.value;
-      })
-      .join("");
-  }
-
-  getCell(col: number, row: number, sheetName?: string): Cell | null {
-    let r;
-    if (!sheetName) {
-      r = this.workbook.activeSheet.rows[row];
-    } else {
-      const sheet = Object.values(this.workbook.sheets).find((x) => x.name === sheetName);
-      if (sheet) {
-        r = sheet.rows[row];
-      } else {
-        return null;
-      }
-    }
-    return r ? r.cells[col] || null : null;
-  }
-
-  getCellText(cell: Cell): string {
-    const value: unknown = this.showFormulas ? cell.content : cell.value;
-    const shouldFormat = (value || value === 0) && cell.format && !cell.error && !cell.pending;
-    const dateTimeFormat = shouldFormat && cell.format!.match(/y|m|d|:/);
-    const numberFormat = shouldFormat && !dateTimeFormat;
-    switch (typeof value) {
-      case "string":
-        return value;
-      case "boolean":
-        return value ? "TRUE" : "FALSE";
-      case "number":
-        if (dateTimeFormat) {
-          return formatDateTime({ value, format: cell.format! });
-        }
-        if (numberFormat) {
-          return formatNumber(value, cell.format!);
-        }
-        return formatStandardNumber(value);
-      case "object":
-        if (!value) return "0";
-        if ("value" in value && "format" in value) {
-          if (dateTimeFormat) {
-            return formatDateTime(value as InternalDate, cell.format);
-          }
-          if (numberFormat) {
-            return formatNumber((value as any).value, cell.format!);
-          }
-          if (value && (value as InternalDate).format.match(/y|m|d|:/)) {
-            return formatDateTime(value as InternalDate);
-          }
-        }
-        return value.toString();
-    }
-    return "";
-  }
-
-  /**
-   * Converts a zone to a XC coordinate system
-   *
-   * The conversion also treats merges as one single cell
-   *
-   * Examples:
-   * {top:0,left:0,right:0,bottom:0} ==> A1
-   * {top:0,left:0,right:1,bottom:1} ==> A1:B2
-   *
-   * if A1:B2 is a merge:
-   * {top:0,left:0,right:1,bottom:1} ==> A1
-   * {top:1,left:0,right:1,bottom:2} ==> A1:B3
-   *
-   * if A1:B2 and A4:B5 are merges:
-   * {top:1,left:0,right:1,bottom:3} ==> A1:A5
-   */
-  zoneToXC(zone: Zone): string {
-    zone = this.getters.expandZone(zone);
-    const topLeft = toXC(zone.left, zone.top);
-    const botRight = toXC(zone.right, zone.bottom);
-    if (
-      topLeft != botRight &&
-      this.getters.getMainCell(topLeft) !== this.getters.getMainCell(botRight)
-    ) {
-      return topLeft + ":" + botRight;
-    }
-
-    return topLeft;
-  }
-
-  /**
-   * Returns the id (not the name) of the currently active sheet
-   */
-  getActiveSheet(): string {
-    return this.workbook.activeSheet.id;
-  }
-
-  getSheetName(sheetId: string): string | undefined {
-    return this.workbook.sheets[sheetId] && this.workbook.sheets[sheetId].name;
-  }
-
-  getSheetIdByName(name: string | undefined): string | undefined {
-    return name && this.sheetIds[getUnquotedSheetName(name)];
-  }
-
-  getSheets(): Sheet[] {
-    const { visibleSheets, sheets } = this.workbook;
-    return visibleSheets.map((id) => sheets[id]);
-  }
-
-  getCol(sheetId: string, index: number): Col {
-    return this.workbook.sheets[sheetId].cols[index];
-  }
-
-  getRow(sheetId: string, index: number): Row {
-    return this.workbook.sheets[sheetId].rows[index];
-  }
-
-  /**
-   * Returns all the cells of a col
-   */
-  getColCells(col: number): Cell[] {
-    return this.workbook.activeSheet.rows.reduce(
-      (acc: Cell[], cur) => (cur.cells[col] ? acc.concat(cur.cells[col]) : acc),
-      []
-    );
-  }
-
-  getNumberCols(sheetId: string): number {
-    return this.workbook.sheets[sheetId].cols.length;
-  }
-
-  getNumberRows(sheetId: string): number {
-    return this.workbook.sheets[sheetId].rows.length;
-  }
-
-  getColsZone(start: number, end: number): Zone {
-    return {
-      top: 0,
-      bottom: this.workbook.activeSheet.rows.length - 1,
-      left: start,
-      right: end,
-    };
-  }
-
-  getRowsZone(start: number, end: number): Zone {
-    return {
-      top: start,
-      bottom: end,
-      left: 0,
-      right: this.workbook.activeSheet.cols.length - 1,
-    };
-  }
-
-  getGridSize(): [number, number] {
-    const activeSheet = this.workbook.activeSheet;
-    const height = activeSheet.rows[activeSheet.rows.length - 1].end + DEFAULT_CELL_HEIGHT + 5;
-    const width = activeSheet.cols[activeSheet.cols.length - 1].end + DEFAULT_CELL_WIDTH;
-
-    return [width, height];
-  }
-
-  shouldShowFormulas(): boolean {
-    return this.showFormulas;
-  }
-
-  getRangeValues(reference: string, defaultSheetId: string): any[][] {
-    const [range, sheetName] = reference.split("!").reverse();
-    const sheetId = sheetName ? this.sheetIds[sheetName] : defaultSheetId;
-    return mapCellsInZone(toZone(range), this.workbook.sheets[sheetId], (cell) => cell.value);
-  }
-
-  getRangeFormattedValues(reference: string, defaultSheetId: string): string[][] {
-    const [range, sheetName] = reference.split("!").reverse();
-    const sheetId = sheetName ? this.sheetIds[sheetName] : defaultSheetId;
-    return mapCellsInZone(
-      toZone(range),
-      this.workbook.sheets[sheetId],
-      this.getters.getCellText,
-      ""
-    );
-  }
-
-  // ---------------------------------------------------------------------------
-  // Row/Col manipulation
-  // ---------------------------------------------------------------------------
-
-  private getColMaxWidth(index: number): number {
-    const cells = this.workbook.activeSheet.rows.reduce(
-      (acc: Cell[], cur) => (cur.cells[index] ? acc.concat(cur.cells[index]) : acc),
-      []
-    );
-    const sizes = cells.map(this.getters.getCellWidth);
-    return Math.max(0, ...sizes);
-  }
-
-  private getRowMaxHeight(index: number): number {
-    const cells = Object.values(this.workbook.activeSheet.rows[index].cells);
-    const sizes = cells.map(this.getters.getCellHeight);
-    return Math.max(0, ...sizes);
-  }
-
-  private setColSize(sheetId: string, index: number, size: number) {
-    const cols = this.workbook.sheets[sheetId].cols;
-    const col = cols[index];
-    const delta = size - col.size;
-    this.history.updateState(["sheets", sheetId, "cols", index, "size"], size);
-    this.history.updateState(["sheets", sheetId, "cols", index, "end"], col.end + delta);
-    for (let i = index + 1; i < cols.length; i++) {
-      const col = cols[i];
-      this.history.updateState(["sheets", sheetId, "cols", i, "start"], col.start + delta);
-      this.history.updateState(["sheets", sheetId, "cols", i, "end"], col.end + delta);
-    }
-  }
-
-  private setRowSize(sheetId: string, index: number, size: number) {
-    const rows = this.workbook.sheets[sheetId].rows;
-    const row = rows[index];
-    const delta = size - row.size;
-    this.history.updateState(["sheets", sheetId, "rows", index, "size"], size);
-    this.history.updateState(["sheets", sheetId, "rows", index, "end"], row.end + delta);
-    for (let i = index + 1; i < rows.length; i++) {
-      const row = rows[i];
-      this.history.updateState(["sheets", sheetId, "rows", i, "start"], row.start + delta);
-      this.history.updateState(["sheets", sheetId, "rows", i, "end"], row.end + delta);
-    }
-  }
-
-  /**
-   * Delete column. This requires a lot of handling:
-   * - Update all the formulas in all sheets
-   * - Move the cells
-   * - Update the cols/rows (size, number, (cells), ...)
-   * - Reevaluate the cells
-   *
-   * @param sheetID ID of the sheet on which deletion should be applied
-   * @param columns Columns to delete
-   */
-  private removeColumns(sheetID: string, columns: number[]) {
-    // This is necessary because we have to delete elements in correct order:
-    // begin with the end.
-    columns.sort((a, b) => b - a);
-    for (let column of columns) {
-      // Update all the formulas.
-      this.updateColumnsFormulas(column, -1, sheetID);
-
-      // Move the cells.
-      this.moveCellsHorizontally(column, -1, sheetID);
-
-      // Effectively delete the element and recompute the left-right.
-      this.manageColumnsHeaders(column, -1, sheetID);
-    }
-  }
-
-  /**
-   * Delete row. This requires a lot of handling:
-   * - Update the merges
-   * - Update all the formulas in all sheets
-   * - Move the cells
-   * - Update the cols/rows (size, number, (cells), ...)
-   * - Reevaluate the cells
-   *
-   * @param sheetID ID of the sheet on which deletion should be applied
-   * @param rows Rows to delete
-   */
-  private removeRows(sheetID: string, rows: number[]) {
-    // This is necessary because we have to delete elements in correct order:
-    // begin with the end.
-    rows.sort((a, b) => b - a);
-
-    const consecutiveRows = rows.reduce((groups, currentRow, index, rows) => {
-      if (currentRow - rows[index - 1] === -1) {
-        const lastGroup = groups[groups.length - 1];
-        lastGroup.push(currentRow);
-      } else {
-        groups.push([currentRow]);
-      }
-      return groups;
-    }, [] as number[][]);
-
-    for (let group of consecutiveRows) {
-      // Update all the formulas.
-      this.updateRowsFormulas(group[0], -group.length, sheetID);
-
-      // Move the cells.
-      this.moveCellVerticallyBatched(group[group.length - 1], group[0], sheetID);
-
-      // Effectively delete the element and recompute the left-right/top-bottom.
-      group.map((row) => this.processRowsHeaderDelete(row, sheetID));
-    }
-  }
-
-  private addColumns(
-    sheetID: string,
-    column: number,
-    position: "before" | "after",
-    quantity: number
-  ) {
-    // Update all the formulas.
-    this.updateColumnsFormulas(position === "before" ? column - 1 : column, quantity, sheetID);
-
-    // Move the cells.
-    this.moveCellsHorizontally(position === "before" ? column : column + 1, quantity, sheetID);
-
-    // Recompute the left-right/top-bottom.
-    this.manageColumnsHeaders(column, quantity, sheetID);
-  }
-
-  private addRows(sheetID: string, row: number, position: "before" | "after", quantity: number) {
-    for (let i = 0; i < quantity; i++) {
-      this.addEmptyRow();
-    }
-    // Update all the formulas.
-    this.updateRowsFormulas(position === "before" ? row - 1 : row, quantity, sheetID);
-
-    // Move the cells.
-    this.moveCellsVertically(position === "before" ? row : row + 1, quantity, sheetID);
-
-    // Recompute the left-right/top-bottom.
-    this.processRowsHeaderAdd(row, quantity);
-  }
-
-  private moveCellsHorizontally(base: number, step: number, sheetID: string) {
-    return this.processCellsToMove(
-      (cell) => cell.col >= base,
-      (cell) => cell.col !== base || step !== -1,
-      (cell) => {
-        return {
-          type: "UPDATE_CELL",
-          sheet: sheetID,
-          col: cell.col + step,
-          row: cell.row,
-          content: cell.content,
-          border: cell.border,
-          style: cell.style,
-          format: cell.format,
-        };
-      },
-      sheetID
-    );
-  }
-
-  /**
-   * Move all the cells that are from the row under `deleteToRow` up to `deleteFromRow`
-   *
-   * b.e.
-   * move vertically with delete from 3 and delete to 5 will first clear all the cells from lines 3 to 5,
-   * then take all the row starting at index 6 and add them back at index 3
-   *
-   * @param deleteFromRow the row index from which to start deleting
-   * @param deleteToRow the row index until which the deleting must continue
-   * @param the sheet from which to remove
-   */
-  private moveCellVerticallyBatched(deleteFromRow: number, deleteToRow: number, sheetID: string) {
-    return this.processCellsToMove(
-      ({ row }) => row >= deleteFromRow,
-      ({ row }) => row > deleteToRow,
-      (cell) => {
-        return {
-          type: "UPDATE_CELL",
-          sheet: this.workbook.sheets[sheetID].id,
-          col: cell.col,
-          row: cell.row - (deleteToRow - deleteFromRow + 1),
-          content: cell.content,
-          border: cell.border,
-          style: cell.style,
-          format: cell.format,
-        };
-      },
-      sheetID
-    );
-  }
-
-  private moveCellsVertically(base: number, step: number, sheetID: string) {
-    return this.processCellsToMove(
-      (cell) => cell.row >= base,
-      (cell) => cell.row !== base || step !== -1,
-      (cell) => {
-        return {
-          type: "UPDATE_CELL",
-          sheet: sheetID,
-          col: cell.col,
-          row: cell.row + step,
-          content: cell.content,
-          border: cell.border,
-          style: cell.style,
-          format: cell.format,
-        };
-      },
-      sheetID
-    );
-  }
-
-  private manageColumnsHeaders(base: number, step: number, sheetID: string) {
-    const cols: Col[] = [];
-    let start = 0;
-    let colIndex = 0;
-    const sheet = this.workbook.sheets[sheetID];
-    for (let i in sheet.cols) {
-      if (parseInt(i, 10) === base) {
-        if (step !== -1) {
-          const { size } = sheet.cols[colIndex];
-          for (let a = 0; a < step; a++) {
-            cols.push({
-              name: numberToLetters(colIndex),
-              size,
-              start,
-              end: start + size,
-            });
-            start += size;
-            colIndex++;
-          }
-        } else {
-          continue;
-        }
-      }
-      const { size } = sheet.cols[i];
-      cols.push({
-        name: numberToLetters(colIndex),
-        size,
-        start,
-        end: start + size,
-      });
-      start += size;
-      colIndex++;
-    }
-    this.history.updateState(["sheets", sheetID, "cols"], cols);
-  }
-
-  private processRowsHeaderDelete(index: number, sheetID: string) {
-    const rows: Row[] = [];
-    let start = 0;
-    let rowIndex = 0;
-    const sheet = this.workbook.sheets[sheetID];
-    const cellsQueue = sheet.rows.map((row) => row.cells);
-    for (let i in sheet.rows) {
-      const row = sheet.rows[i];
-      const { size } = row;
-      if (parseInt(i, 10) === index) {
-        continue;
-      }
-      rowIndex++;
-      rows.push({
-        start,
-        end: start + size,
-        size,
-        cells: cellsQueue.shift()!,
-        name: String(rowIndex),
-      });
-      start += size;
-    }
-    this.history.updateState(["sheets", sheetID, "rows"], rows);
-  }
-
-  private processRowsHeaderAdd(index: number, quantity: number) {
-    const rows: Row[] = [];
-    let start = 0;
-    let rowIndex = 0;
-    let sizeIndex = 0;
-    const cellsQueue = this.workbook.activeSheet.rows.map((row) => row.cells);
-    for (let i in this.workbook.activeSheet.rows) {
-      const { size } = this.workbook.activeSheet.rows[sizeIndex];
-      if (parseInt(i, 10) < index || parseInt(i, 10) >= index + quantity) {
-        sizeIndex++;
-      }
-      rowIndex++;
-      rows.push({
-        start,
-        end: start + size,
-        size,
-        cells: cellsQueue.shift()!,
-        name: String(rowIndex),
-      });
-      start += size;
-    }
-    this.history.updateState(["activeSheet", "rows"], rows);
-  }
-
-  private addEmptyRow() {
-    const lastEnd = this.workbook.activeSheet.rows[this.workbook.activeSheet.rows.length - 1].end;
-    const name = (this.workbook.activeSheet.rows.length + 1).toString();
-    const newRows: Row[] = this.workbook.activeSheet.rows.slice();
-    const size = 0;
-    newRows.push({
-      start: lastEnd,
-      end: lastEnd + size,
-      size,
-      name,
-      cells: {},
-    });
-    const path = ["activeSheet", "rows"];
-    this.history.updateState(path, newRows);
-  }
-
-  private updateColumnsFormulas(base: number, step: number, sheetID: string) {
-    return this.visitFormulas(
-      this.workbook.sheets[sheetID].name,
-      (value: string, sheet: string | undefined): string => {
-        if (value.includes(":")) {
-          return this.updateColumnsRange(value, sheet, base, step);
-        }
-        return this.updateColumnsRef(value, sheet, base, step);
-      }
-    );
-  }
-
-  private updateRowsFormulas(base: number, step: number, sheetID: string) {
-    return this.visitFormulas(
-      this.workbook.sheets[sheetID].name,
-      (value: string, sheet: string | undefined): string => {
-        if (value.includes(":")) {
-          return this.updateRowsRange(value, sheet, base, step);
-        }
-        return this.updateRowsRef(value, sheet, base, step);
-      }
-    );
-  }
-
-  private processCellsToMove(
-    shouldDelete: (cell: Cell) => boolean,
-    shouldAdd: (cell: Cell) => boolean,
-    buildCellToAdd: (cell: Cell) => Command,
-    sheetId
-  ) {
-    const deleteCommands: Command[] = [];
-    const addCommands: Command[] = [];
-
-    const sheet = this.workbook.sheets[sheetId];
-
-    for (let xc in sheet.cells) {
-      let cell = sheet.cells[xc];
-      if (shouldDelete(cell)) {
-        const [col, row] = toCartesian(xc);
-        deleteCommands.push({
-          type: "CLEAR_CELL",
-          sheet: sheet.id,
-          col,
-          row,
-        });
-        if (shouldAdd(cell)) {
-          addCommands.push(buildCellToAdd(cell));
-        }
-      }
-    }
-    for (let cmd of deleteCommands) {
-      this.dispatch(cmd.type, cmd);
-    }
-    for (let cmd of addCommands) {
-      this.dispatch(cmd.type, cmd);
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Cells
-  // ---------------------------------------------------------------------------
-
-  private updateCell(sheet: string, col: number, row: number, data: CellData) {
-    const _sheet = this.workbook.sheets[sheet];
-    const current = _sheet.rows[row].cells[col];
-    const xc = (current && current.xc) || toXC(col, row);
-    const hasContent = "content" in data;
-
-    // Compute the new cell properties
-    const dataContent = data.content ? data.content.replace(nbspRegexp, "") : "";
-    let content = hasContent ? dataContent : (current && current.content) || "";
-    const style = "style" in data ? data.style : (current && current.style) || 0;
-    const border = "border" in data ? data.border : (current && current.border) || 0;
-    let format = "format" in data ? data.format : (current && current.format) || "";
-
-    // if all are empty, we need to delete the underlying cell object
-    if (!content && !style && !border && !format) {
-      if (current) {
-        // todo: make this work on other sheets
-        this.history.updateSheet(_sheet, ["cells", xc], undefined);
-        this.history.updateSheet(_sheet, ["rows", row, "cells", col], undefined);
-      }
-      return;
-    }
-
-    // compute the new cell value
-    const didContentChange =
-      (!current && dataContent) || (hasContent && current && current.content !== dataContent);
-    let cell: Cell;
-    if (current && !didContentChange) {
-      cell = { col, row, xc, content, value: current.value, type: current.type };
-      if (cell.type === "formula") {
-        cell.error = current.error;
-        cell.pending = current.pending;
-        cell.formula = current.formula;
-      }
-    } else {
-      // the current content cannot be reused, so we need to recompute the
-      // derived values
-      let type: Cell["type"] = content[0] === "=" ? "formula" : "text";
-      let value: Cell["value"] = content;
-      if (isNumber(content)) {
-        value = parseNumber(content);
-        type = "number";
-        if (content.includes("%")) {
-          format = content.includes(".") ? "0.00%" : "0%";
-        }
-      }
-      let date = parseDateTime(content);
-      if (date) {
-        type = "date";
-        value = date;
-        content = formatDateTime(date);
-      }
-      const contentUpperCase = content.toUpperCase();
-      if (contentUpperCase === "TRUE") {
-        value = true;
-      }
-      if (contentUpperCase === "FALSE") {
-        value = false;
-      }
-      cell = { col, row, xc, content, value, type };
-      if (cell.type === "formula") {
-        cell.error = undefined;
-        try {
-          let formulaString: NormalizedFormula = normalize(cell.content || "");
-          let compiledFormula = compile(formulaString);
-          cell.formula = {
-            compiledFormula: compiledFormula,
-            dependencies: formulaString.dependencies,
-            text: formulaString.text,
-          };
-        } catch (e) {
-          cell.value = "#BAD_EXPR";
-          cell.error = e.message || _lt("Invalid Expression");
-        }
-      }
-    }
-    if (style) {
-      cell.style = style;
-    }
-    if (border) {
-      cell.border = border;
-    }
-    if (format) {
-      cell.format = format;
-    }
-    // todo: make this work on other sheets
-    this.history.updateSheet(_sheet, ["cells", xc], cell);
-    this.history.updateSheet(_sheet, ["rows", row, "cells", col], cell);
-  }
-
-  private generateSheetName(): string {
-    let i = 1;
-    const names = this.getSheets().map((s) => s.name);
-    const baseName = _lt("Sheet");
-    let name = `${baseName}${i}`;
-    while (names.includes(name)) {
-      name = `${baseName}${i}`;
-      i++;
-    }
-    return name;
-  }
-
-  private createSheet(id: string, name: string, cols: number, rows: number): string {
-    const sheet: Sheet = {
-      id,
-      name,
-      cells: {},
-      colNumber: cols,
-      rowNumber: rows,
-      cols: createDefaultCols(cols),
-      rows: createDefaultRows(rows),
-      merges: {},
-      mergeCellMap: {},
-    };
-    const visibleSheets = this.workbook.visibleSheets.slice();
-    const index = visibleSheets.findIndex((id) => this.workbook.activeSheet.id === id);
-    visibleSheets.splice(index + 1, 0, sheet.id);
-    const sheets = this.workbook.sheets;
-    this.history.updateState(["visibleSheets"], visibleSheets);
-    this.history.updateState(["sheets"], Object.assign({}, sheets, { [sheet.id]: sheet }));
-    return sheet.id;
-  }
-
-  private moveSheet(sheetId: string, direction: "left" | "right") {
-    const visibleSheets = this.workbook.visibleSheets.slice();
-    const currentIndex = visibleSheets.findIndex((id) => id === sheetId);
-    const sheet = visibleSheets.splice(currentIndex, 1);
-    visibleSheets.splice(currentIndex + (direction === "left" ? -1 : 1), 0, sheet[0]);
-    this.history.updateState(["visibleSheets"], visibleSheets);
-  }
-
-  private isRenameAllowed(cmd: RenameSheetCommand): CommandResult {
-    if (cmd.interactive) {
-      return { status: "SUCCESS" };
-    }
-    const name = cmd.name && cmd.name.trim().toLowerCase();
-    if (!name) {
-      return { status: "CANCELLED", reason: CancelledReason.WrongSheetName };
-    }
-    return this.workbook.visibleSheets.findIndex(
-      (id) => this.workbook.sheets[id].name.toLowerCase() === name
-    ) === -1
-      ? { status: "SUCCESS" }
-      : { status: "CANCELLED", reason: CancelledReason.WrongSheetName };
-  }
-
-  private interactiveRenameSheet(sheet: string, title: string) {
-    const placeholder = this.getSheetName(sheet)!;
-    this.ui.editText(title, placeholder, (name: string | null) => {
-      if (!name) {
-        return;
-      }
-      const result = this.dispatch("RENAME_SHEET", { sheet, name });
-      const sheetName = this.getSheetName(sheet);
-      if (result.status === "CANCELLED" && sheetName !== name) {
-        this.interactiveRenameSheet(sheet, _lt("Please enter a valid sheet name"));
-      }
-    });
-  }
-
-  private renameSheet(sheetId: string, name: string) {
-    const sheet = this.workbook.sheets[sheetId];
-    const oldName = sheet.name;
-    this.history.updateSheet(sheet, ["name"], name.trim());
-    const sheetIds = Object.assign({}, this.sheetIds);
-    sheetIds[name] = sheet.id;
-    delete sheetIds[oldName];
-    this.history.updateLocalState(["sheetIds"], sheetIds);
-    this.visitAllFormulasSymbols((value: string) => {
-      let [val, sheetRef] = value.split("!").reverse();
-      if (sheetRef) {
-        sheetRef = getUnquotedSheetName(sheetRef);
-        if (sheetRef === oldName) {
-          if (val.includes(":")) {
-            return this.updateRange(val, 0, 0, sheet.id);
-          }
-          return this.updateReference(val, 0, 0, sheet.id);
-        }
-      }
-      return value;
-    });
-  }
-
-  private duplicateSheet(fromId: string, toId: string, toName: string) {
-    const sheet = this.workbook.sheets[fromId];
-    const newSheet = JSON.parse(JSON.stringify(sheet));
-    newSheet.id = toId;
-    newSheet.name = toName;
-    const visibleSheets = this.workbook.visibleSheets.slice();
-    const currentIndex = visibleSheets.findIndex((id) => id === fromId);
-    visibleSheets.splice(currentIndex + 1, 0, newSheet.id);
-    this.history.updateState(["visibleSheets"], visibleSheets);
-    this.history.updateState(
-      ["sheets"],
-      Object.assign({}, this.workbook.sheets, { [newSheet.id]: newSheet })
-    );
-
-    const sheetIds = Object.assign({}, this.sheetIds);
-    sheetIds[newSheet.name] = newSheet.id;
-    this.history.updateLocalState(["sheetIds"], sheetIds);
-    this.dispatch("ACTIVATE_SHEET", { from: this.workbook.activeSheet.id, to: toId });
-  }
-
-  private interactiveDeleteSheet(sheetId: string) {
-    this.ui.askConfirmation(_lt("Are you sure you want to delete this sheet ?"), () => {
-      this.dispatch("DELETE_SHEET", { sheet: sheetId });
-    });
-  }
-
-  private deleteSheet(sheetId: string) {
-    const name = this.workbook.sheets[sheetId].name;
-    const sheets = Object.assign({}, this.workbook.sheets);
-    delete sheets[sheetId];
-    this.history.updateState(["sheets"], sheets);
-
-    const visibleSheets = this.workbook.visibleSheets.slice();
-    const currentIndex = visibleSheets.findIndex((id) => id === sheetId);
-    visibleSheets.splice(currentIndex, 1);
-    this.history.updateState(["visibleSheets"], visibleSheets);
-
-    const sheetIds = Object.assign({}, this.sheetIds);
-    delete sheetIds[name];
-    this.history.updateLocalState(["sheetIds"], sheetIds);
-    this.visitAllFormulasSymbols((value: string) => {
-      let [, sheetRef] = value.split("!").reverse();
-      if (sheetRef) {
-        sheetRef = getUnquotedSheetName(sheetRef);
-        if (sheetRef === name) {
-          return "#REF";
-        }
-      }
-      return value;
-    });
-    if (this.getActiveSheet() === sheetId) {
-      this.dispatch("ACTIVATE_SHEET", {
-        from: sheetId,
-        to: visibleSheets[Math.max(0, currentIndex - 1)],
-      });
-    }
-  }
-
-  private clearZones(sheet: string, zones: Zone[]) {
-    // TODO: get cells from the actual sheet
-    const cells = this.workbook.activeSheet.cells;
-    for (let zone of zones) {
-      for (let col = zone.left; col <= zone.right; col++) {
-        for (let row = zone.top; row <= zone.bottom; row++) {
-          const xc = toXC(col, row);
-          if (xc in cells) {
-            this.dispatch("UPDATE_CELL", {
-              sheet,
-              content: "",
-              col,
-              row,
-            });
-          }
-        }
-      }
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Cols/Rows addition/deletion offsets manipulation
-  // ---------------------------------------------------------------------------
-
-  /**
-   * Update a reference by applying an offset to the column
-   *
-   * @param ref Reference to update
-   * @param sheet Id of the sheet, if cross-sheet reference
-   * @param base Index of the element added/removed
-   * @param step Number of elements added or -1 if removed
-   */
-  private updateColumnsRef = (
-    ref: string,
-    sheet: string | undefined,
-    base: number,
-    step: number
-  ): string => {
-    let x = toCartesian(ref)[0];
-    if (x === base && step === -1) {
-      return "#REF";
-    }
-    return this.updateReference(ref, x > base ? step : 0, 0, this.getSheetIdByName(sheet), false);
-  };
-
-  /**
-   * Update a full range by appling an offset.
-   *
-   * @param ref Reference to update
-   * @param sheet Id of the sheet, if cross-sheet reference
-   * @param base Index of the element added/removed
-   * @param step Number of elements added or -1 if removed
-   */
-  private updateColumnsRange = (
-    ref: string,
-    sheet: string | undefined,
-    base: number,
-    step: number
-  ): string => {
-    const currentZone = toZone(ref);
-    const recomputedRefs =
-      step < 0
-        ? recomputeZones(
-            [ref],
-            [this.zoneToXC({ ...currentZone, left: base + step + 1, right: base })]
-          )
-        : [ref];
-
-    if (recomputedRefs.length === 0) {
-      return "#REF";
-    }
-
-    const leftZone = toZone(recomputedRefs[0]);
-
-    const rightZone =
-      step < 0 && currentZone.left < base + step + 1 && base < currentZone.right
-        ? toZone(recomputedRefs[1])
-        : leftZone;
-
-    const left = base < leftZone.left ? leftZone.left + step : leftZone.left;
-    const right = base < rightZone.right ? rightZone.right + step : rightZone.right;
-
-    const [leftXc, rightXc] = ref.split(":");
-    const sheetId = this.getters.getSheetIdByName(sheet);
-    const newLeft = this.updateReference(leftXc, left - currentZone.left, 0, sheetId, false, false);
-    const newRight = this.updateReference(
-      rightXc,
-      right - currentZone.right,
-      0,
-      sheetId,
-      false,
-      false
-    );
-    if (newLeft === newRight) {
-      return newLeft;
-    }
-    //As updateReference put the sheet in the ref, we need to remove it from the right part
-    return `${newLeft}:${newRight.split("!").pop()!}`;
-  };
-
-  /**
-   * Update a reference by applying an offset to the row
-   *
-   * @param ref Reference to update
-   * @param sheet Id of the sheet, if cross-sheet reference
-   * @param base Index of the element added/removed
-   * @param step Number of elements added or -1 if removed
-   */
-  private updateRowsRef = (
-    ref: string,
-    sheet: string | undefined,
-    base: number,
-    step: number
-  ): string => {
-    let y = toCartesian(ref)[1];
-    if (base + step < y && y <= base) {
-      return "#REF";
-    }
-    return this.updateReference(ref, 0, y > base ? step : 0, this.getSheetIdByName(sheet), false);
-  };
-
-  /**
-   * Update a full range by appling an offset.
-   *
-   * @param ref Reference to update
-   * @param sheet Id of the sheet, if cross-sheet reference
-   * @param base Index of the element added/removed
-   * @param step Number of elements added/removed (negative when removed)
-   */
-  private updateRowsRange = (
-    ref: string,
-    sheet: string | undefined,
-    base: number,
-    step: number
-  ): string => {
-    const currentZone = toZone(ref);
-    // base+step+1 === left element of the zone to remove
-    const recomputedRefs =
-      step < 0
-        ? recomputeZones(
-            [ref],
-            [this.zoneToXC({ ...currentZone, top: base + step + 1, bottom: base })]
-          )
-        : [ref];
-
-    if (recomputedRefs.length === 0) {
-      return "#REF";
-    }
-
-    const topZone = toZone(recomputedRefs[0]);
-
-    // base+step+1 === top element of the zone to remove
-    const bottomZone =
-      step < 0 && currentZone.top < base + step + 1 && base < currentZone.bottom
-        ? toZone(recomputedRefs[1])
-        : topZone;
-
-    const top = base < topZone.top ? topZone.top + step : topZone.top;
-    const bottom = base < bottomZone.bottom ? bottomZone.bottom + step : bottomZone.bottom;
-
-    const [left, right] = ref.split(":");
-    const sheetId = this.getters.getSheetIdByName(sheet);
-    const newLeft = this.updateReference(left, 0, top - currentZone.top, sheetId, false, false);
-    const newRight = this.updateReference(
-      right,
-      0,
-      bottom - currentZone.bottom,
-      sheetId,
-      false,
-      false
-    );
-    if (newLeft === newRight) {
-      return newLeft;
-    }
-    //As updateReference put the sheet in the ref, we need to remove it from the right part
-    return `${newLeft}:${newRight.split("!").pop()!}`;
-  };
-
-  // ---------------------------------------------------------------------------
-  // Helpers
-  // ---------------------------------------------------------------------------
-
-  /**
-   * Update a range with some offsets
-   */
-  private updateRange(
-    symbol: string,
-    offsetX: number,
-    offsetY: number,
-    sheetId: string | undefined
-  ): string {
-    let [left, right] = symbol.split(":");
-    left = this.updateReference(left, offsetX, offsetY, sheetId, true, false);
-    right = this.updateReference(right, offsetX, offsetY, sheetId, true, false);
-    if (left === "#REF" || right === "#REF") {
-      return "#REF";
-    }
-    //As updateReference put the sheet in the ref, we need to remove it from the right part
-    right = right.split("!").pop()!;
-    return `${left}:${right}`;
-  }
-
-  /**
-   * Update a reference with some offsets.
-   */
-  private updateReference(
-    symbol: string,
-    offsetX: number,
-    offsetY: number,
-    sheetId: string | undefined,
-    updateFreeze: boolean = true,
-    checkSheetBoundary: boolean = true
-  ): string {
-    const xc = symbol.replace(/\$/g, "");
-    let [x, y] = toCartesian(xc);
-    const freezeCol = symbol.startsWith("$");
-    const freezeRow = symbol.includes("$", 1);
-    x += freezeCol && updateFreeze ? 0 : offsetX;
-    y += freezeRow && updateFreeze ? 0 : offsetY;
-    if (
-      x < 0 ||
-      y < 0 ||
-      (checkSheetBoundary &&
-        (x >= this.getters.getNumberCols(sheetId || this.getters.getActiveSheet()) ||
-          y >= this.getters.getNumberRows(sheetId || this.getters.getActiveSheet())))
-    ) {
-      return "#REF";
-    }
-    const sheetName = sheetId && getComposerSheetName(this.getters.getSheetName(sheetId)!);
-    return (
-      (sheetName ? `${sheetName}!` : "") +
-      (freezeCol ? "$" : "") +
-      numberToLetters(x) +
-      (freezeRow ? "$" : "") +
-      String(y + 1)
-    );
-  }
-
-  private visitAllFormulasSymbols(cb: (value: string, sheetId: string) => string) {
-    for (let sheetId in this.workbook.sheets) {
-      const sheet = this.workbook.sheets[sheetId];
-      for (let [xc, cell] of Object.entries(sheet.cells)) {
-        if (cell.type === "formula") {
-          const content = rangeTokenize(cell.content!)
-            .map((t) => {
-              if (t.type === "SYMBOL" && cellReference.test(t.value)) {
-                return cb(t.value, sheet.id);
-              }
-              return t.value;
-            })
-            .join("");
-          if (content !== cell.content) {
-            const [col, row] = toCartesian(xc);
-            this.dispatch("UPDATE_CELL", {
-              sheet: sheet.id,
-              col,
-              row,
-              content,
-            });
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Apply a function to update the formula on every cells of every sheets which
-   * contains a formula
-   * @param cb Update formula function to apply
-   */
-  private visitFormulas(
-    sheetNameToFind: string,
-    cb: (value: string, sheet: string | undefined) => string
-  ) {
-    this.visitAllFormulasSymbols((content: string, sheetId: string): string => {
-      let [value, sheetRef] = content.split("!").reverse();
-      if (sheetRef) {
-        sheetRef = getUnquotedSheetName(sheetRef);
-        if (sheetRef === sheetNameToFind) {
-          return cb(value, sheetRef);
-        }
-      } else if (this.sheetIds[sheetNameToFind] === sheetId) {
-        return cb(value, undefined);
-      }
-      return content;
-    });
-  }
-
-  // ---------------------------------------------------------------------------
-  // Import/Export
-  // ---------------------------------------------------------------------------
-
-  import(data: WorkbookData) {
-    // we need to fill the sheetIds mapping first, because otherwise formulas
-    // that depends on a sheet not already imported will not be able to be
-    // compiled
-    for (let sheet of data.sheets) {
-      this.sheetIds[sheet.name] = sheet.id;
-    }
-
-    for (let sheet of data.sheets) {
-      this.importSheet(sheet);
-    }
-    this.workbook.activeSheet = this.workbook.sheets[data.activeSheet];
-  }
-
-  importSheet(data: SheetData) {
-    let { sheets, visibleSheets } = this.workbook;
-    const name = data.name || `Sheet${Object.keys(sheets).length + 1}`;
-    const { colNumber, rowNumber } = getSheetSize(data);
-    const sheet: Sheet = {
-      id: data.id,
-      name: name,
-      cells: {},
-      colNumber,
-      rowNumber,
-      cols: createCols(data.cols || {}, colNumber),
-      rows: createRows(data.rows || {}, rowNumber),
-      merges: {},
-      mergeCellMap: {},
-    };
-    visibleSheets = visibleSheets.slice();
-    visibleSheets.push(sheet.id);
-    this.history.updateState(["visibleSheets"], visibleSheets);
-    this.history.updateState(["sheets"], Object.assign({}, sheets, { [sheet.id]: sheet }));
-    // cells
-    for (let xc in data.cells) {
-      const cell = data.cells[xc];
-      const [col, row] = toCartesian(xc);
-      this.updateCell(data.id, col, row, cell);
-    }
-  }
-
-  export(data: WorkbookData) {
-    data.sheets = this.workbook.visibleSheets.map((id) => {
-      const sheet = this.workbook.sheets[id];
-      const cells: { [key: string]: CellData } = {};
-      for (let [key, cell] of Object.entries(sheet.cells)) {
-        cells[key] = {
-          content: cell.content,
-          border: cell.border,
-          style: cell.style,
-          format: cell.format,
-        };
-      }
-      return {
-        id: sheet.id,
-        name: sheet.name,
-        colNumber: sheet.colNumber,
-        rowNumber: sheet.rowNumber,
-        rows: exportRows(sheet.rows),
-        cols: exportCols(sheet.cols),
-        merges: [], //exportMerges(sheet.merges),
-        cells: cells,
-        conditionalFormats: [],
-        figures: [],
-      };
-    });
-    data.activeSheet = this.workbook.activeSheet.id;
-  }
-}
-
-function getSheetSize(data: SheetData): { rowNumber: number; colNumber: number } {
-  const positions = Object.keys(data.cells).map(toCartesian);
-  return {
-    rowNumber: Math.max(data.rowNumber, ...new Set(positions.map(([col, row]) => row + 1))),
-    colNumber: Math.max(data.colNumber, ...new Set(positions.map(([col, row]) => col + 1))),
-  };
-}
-
-function createDefaultCols(colNumber: number): Col[] {
-  const cols: Col[] = [];
-  let current = 0;
-  for (let i = 0; i < colNumber; i++) {
-    const size = DEFAULT_CELL_WIDTH;
-    const col = {
-      start: current,
-      end: current + size,
-      size: size,
-      name: numberToLetters(i),
-    };
-    cols.push(col);
-    current = col.end;
-  }
-  return cols;
-}
-
-function createDefaultRows(rowNumber: number): Row[] {
-  const rows: Row[] = [];
-  let current = 0;
-  for (let i = 0; i < rowNumber; i++) {
-    const size = DEFAULT_CELL_HEIGHT;
-    const row = {
-      start: current,
-      end: current + size,
-      size: size,
-      name: String(i + 1),
-      cells: {},
-    };
-    rows.push(row);
-    current = row.end;
-  }
-  return rows;
-}
-
-function createCols(savedCols: { [key: number]: HeaderData }, colNumber: number): Col[] {
-  const cols: Col[] = [];
-  let current = 0;
-  for (let i = 0; i < colNumber; i++) {
-    const size = savedCols[i] ? savedCols[i].size || DEFAULT_CELL_WIDTH : DEFAULT_CELL_WIDTH;
-    const col = {
-      start: current,
-      end: current + size,
-      size: size,
-      name: numberToLetters(i),
-    };
-    cols.push(col);
-    current = col.end;
-  }
-  return cols;
-}
-
-function createRows(savedRows: { [key: number]: HeaderData }, rowNumber: number): Row[] {
-  const rows: Row[] = [];
-  let current = 0;
-  for (let i = 0; i < rowNumber; i++) {
-    const size = savedRows[i] ? savedRows[i].size || DEFAULT_CELL_HEIGHT : DEFAULT_CELL_HEIGHT;
-    const row = {
-      start: current,
-      end: current + size,
-      size: size,
-      name: String(i + 1),
-      cells: {},
-    };
-    rows.push(row);
-    current = row.end;
-  }
-  return rows;
-}
-
-function exportCols(cols: Col[]): { [key: number]: HeaderData } {
-  const exportedCols: { [key: number]: HeaderData } = {};
-  for (let i in cols) {
-    const col = cols[i];
-    if (col.size !== DEFAULT_CELL_WIDTH) {
-      exportedCols[i] = { size: col.size };
-    }
-  }
-  return exportedCols;
-}
-
-function exportRows(rows: Row[]): { [key: number]: HeaderData } {
-  const exportedRows: { [key: number]: HeaderData } = {};
-  for (let i in rows) {
-    const row = rows[i];
-    if (row.size !== DEFAULT_CELL_HEIGHT) {
-      exportedRows[i] = { size: row.size };
-    }
-  }
-  return exportedRows;
-}