@odoo/o-spreadsheet 14.0.0 → 14.0.1

package/src/helpers/numbers.ts

@@ -0,0 +1,117 @@
+/**
+ * This regexp is supposed to be as close as possible as the numberRegexp, but
+ * its purpose is to be used by the tokenizer.
+ *
+ * - it tolerates extra characters at the end. This is useful because the tokenizer
+ *   only needs to find the number at the start of a string
+ * - it does not accept "," as thousand separator, because when we tokenize a
+ *   formula, commas are used to separate arguments
+ */
+export const formulaNumberRegexp = /^-?\d+(\.?\d*(e\d+)?)?(\s*%)?|^-?\.\d+(\s*%)?/;
+
+export const numberRegexp = /^-?\d+(,\d+)*(\.?\d*(e\d+)?)?(\s*%)?$|^-?\.\d+(\s*%)?$/;
+
+/**
+ * Return true if the argument is a "number string".
+ *
+ * Note that "" (empty string) does not count as a number string
+ */
+export function isNumber(value: string): boolean {
+  // TO DO: add regexp for DATE string format (ex match: "28 02 2020")
+  return numberRegexp.test(value.trim());
+}
+
+const commaRegexp = /,/g;
+/**
+ * Convert a string into a number. It assumes that the string actually represents
+ * a number (as determined by the isNumber function)
+ *
+ * Note that it accepts "" (empty string), even though it does not count as a
+ * number from the point of view of the isNumber function.
+ */
+export function parseNumber(str: string): number {
+  let n = Number(str.replace(commaRegexp, ""));
+  if (isNaN(n) && str.includes("%")) {
+    n = Number(str.split("%")[0]);
+    if (!isNaN(n)) {
+      return n / 100;
+    }
+  }
+  return n;
+}
+
+const decimalStandardRepresentation = new Intl.NumberFormat("en-US", {
+  useGrouping: false,
+  maximumFractionDigits: 10,
+});
+
+export function formatStandardNumber(n: number): string {
+  if (Number.isInteger(n)) {
+    return n.toString();
+  }
+  return decimalStandardRepresentation.format(n);
+}
+
+// this is a cache than can contains decimal representation formats
+// from 0 (minimum) to 20 (maximum) digits after the decimal point
+let decimalRepresentations: Intl.NumberFormat[] = [];
+
+export const maximumDecimalPlaces = 20;
+
+export function formatDecimal(n: number, decimals: number, sep: string = ""): string {
+  if (n < 0) {
+    return "-" + formatDecimal(-n, decimals);
+  }
+  const maxDecimals = decimals >= maximumDecimalPlaces ? maximumDecimalPlaces : decimals;
+
+  let formatter = decimalRepresentations[maxDecimals];
+  if (!formatter) {
+    formatter = new Intl.NumberFormat("en-US", {
+      minimumFractionDigits: maxDecimals,
+      maximumFractionDigits: maxDecimals,
+      useGrouping: false,
+    });
+    decimalRepresentations[maxDecimals] = formatter;
+  }
+  let result = formatter.format(n);
+  if (sep) {
+    let p: number = result.indexOf(".")!;
+    result = result.replace(/\d(?=(?:\d{3})+(?:\.|$))/g, (m, i) =>
+      p < 0 || i < p ? `${m}${sep}` : m
+    );
+  }
+  return result;
+}
+
+export function formatPercent(n: number): string {
+  return formatDecimal(100 * n, 2) + "%";
+}
+
+export function formatNumber(value: any, format: string): string {
+  const parts = format.split(";");
+  const l = parts.length;
+  if (value < 0) {
+    if (l > 1) {
+      return _formatValue(-value, parts[1]);
+    } else {
+      return "-" + _formatValue(-value, parts[0]);
+    }
+  }
+  const index = l === 3 && value === 0 ? 2 : 0;
+  return _formatValue(value, parts[index]);
+}
+
+function _formatValue(value: any, format: string): string {
+  const parts = format.split(".");
+  const decimals = parts.length === 1 ? 0 : parts[1].match(/0/g)!.length;
+  const separator = parts[0].includes(",") ? "," : "";
+  const isPercent = format.includes("%");
+  if (isPercent) {
+    value = value * 100;
+  }
+  const rawNumber = formatDecimal(value, decimals, separator);
+  if (isPercent) {
+    return rawNumber + "%";
+  }
+  return rawNumber;
+}

package/src/helpers/uuid.ts

@@ -0,0 +1,19 @@
+/*
+ * https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript
+ * */
+export function uuidv4(): string {
+  //@ts-ignore
+  if (window.crypto && window.crypto.getRandomValues) {
+    //@ts-ignore
+    return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) =>
+      (c ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16)
+    );
+  } else {
+    // mainly for jest and other browsers that do not have the crypto functionality
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+      var r = (Math.random() * 16) | 0,
+        v = c == "x" ? r : (r & 0x3) | 0x8;
+      return v.toString(16);
+    });
+  }
+}

package/src/helpers/zones.ts

@@ -0,0 +1,263 @@
+import { Cell, Sheet, Zone } from "../types";
+import { toCartesian, toXC } from "./coordinates";
+
+/**
+ * Convert from a cartesian reference to a Zone
+ *
+ * Examples:
+ *    "A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *    "Sheet1!A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "Sheet1!B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *
+ */
+export function toZone(xc: string): Zone {
+  xc = xc.split("!").pop()!;
+  const ranges = xc.replace("$", "").split(":");
+  let top: number, bottom: number, left: number, right: number;
+
+  let c = toCartesian(ranges[0].trim());
+  left = right = c[0];
+  top = bottom = c[1];
+  if (ranges.length === 2) {
+    let d = toCartesian(ranges[1].trim());
+    right = d[0];
+    bottom = d[1];
+    if (right < left) {
+      [right, left] = [left, right];
+    }
+    if (bottom < top) {
+      [bottom, top] = [top, bottom];
+    }
+  }
+
+  return { top, bottom, left, right };
+}
+
+/**
+ * Convert from zone to a cartesian reference
+ *
+ */
+export function zoneToXc(zone: Zone): string {
+  const { top, bottom, left, right } = zone;
+  const isOneCell = top === bottom && left === right;
+  return isOneCell ? toXC(left, top) : `${toXC(left, top)}:${toXC(right, bottom)}`;
+}
+
+/**
+ * Compute the union of two zones. It is the smallest zone which contains the
+ * two arguments.
+ */
+export function union(z1: Zone, z2: Zone): Zone {
+  return {
+    top: Math.min(z1.top, z2.top),
+    left: Math.min(z1.left, z2.left),
+    bottom: Math.max(z1.bottom, z2.bottom),
+    right: Math.max(z1.right, z2.right),
+  };
+}
+
+/**
+ * Two zones are equal if they represent the same area, so we clearly cannot use
+ * reference equality.
+ */
+export function isEqual(z1: Zone, z2: Zone): boolean {
+  return (
+    z1.left === z2.left && z1.right === z2.right && z1.top === z2.top && z1.bottom === z2.bottom
+  );
+}
+
+/**
+ * Return true if two zones overlap, false otherwise.
+ */
+export function overlap(z1: Zone, z2: Zone): boolean {
+  if (z1.bottom < z2.top || z2.bottom < z1.top) {
+    return false;
+  }
+  if (z1.right < z2.left || z2.right < z1.left) {
+    return false;
+  }
+  return true;
+}
+
+export function isInside(col: number, row: number, zone: Zone): boolean {
+  const { left, right, top, bottom } = zone;
+  return col >= left && col <= right && row >= top && row <= bottom;
+}
+
+/**
+ * Recompute the ranges of the zone to contain all the cells in zones, without the cells in toRemoveZones
+ * Also regroup zones together to shorten the string
+ * (A1, A2, B1, B2, [C1:C2], C3 => [A1:B2],[C1:C3])
+ * To do so, the cells are separated and remerged in zones by columns, and then
+ * if possible zones in adjacent columns are merged together.
+ */
+export function recomputeZones(zones: string[], toRemoveZones: string[]): string[] {
+  const zonesPerColumn: {
+    [col: string]: { top: number; bottom: number; remove: boolean }[];
+  } = {};
+  //separate the existing zones per column
+  for (let z of zones) {
+    const zone = toZone(z);
+    for (let col = zone.left; col <= zone.right; col++) {
+      if (zonesPerColumn[col] === undefined) {
+        zonesPerColumn[col] = [];
+      }
+      zonesPerColumn[col].push({
+        top: zone.top,
+        bottom: zone.bottom,
+        remove: false,
+      });
+    }
+  }
+
+  //separate the to deleted zones per column
+  for (let z of toRemoveZones) {
+    const zone = toZone(z);
+    for (let col = zone.left; col <= zone.right; col++) {
+      if (zonesPerColumn[col] === undefined) {
+        zonesPerColumn[col] = [];
+      }
+      zonesPerColumn[col].push({
+        top: zone.top,
+        bottom: zone.bottom,
+        remove: true,
+      });
+    }
+  }
+  const OptimizedZonePerColumn: {
+    col: number;
+    ranges: { top: number; bottom: number }[];
+  }[] = [];
+
+  //regroup zones per column
+  for (let [col, zones] of Object.entries(zonesPerColumn)) {
+    OptimizedZonePerColumn.push({
+      col: parseInt(col),
+      ranges: optimiseColumn(zones),
+    });
+  }
+  //merge zones that spread over multiple columns that can be merged
+  const result = mergeColumns(OptimizedZonePerColumn);
+  return result.map(zoneToXc);
+}
+
+/**
+ * Recompute the ranges of a column, without the remove cells.
+ * takes as input a array of {top, bottom, remove} where top and bottom
+ * are the start and end of ranges in the column and remove expresses if the
+ * cell should be kept or not.
+ */
+function optimiseColumn(
+  zones: { top: number; bottom: number; remove: boolean }[]
+): { top: number; bottom: number }[] {
+  const toKeep: Set<number> = new Set();
+  const toRemove: Set<number> = new Set();
+
+  for (let zone of zones) {
+    for (let x = zone.top; x <= zone.bottom; x++) {
+      zone.remove ? toRemove.add(x) : toKeep.add(x);
+    }
+  }
+  const finalElements: number[] = [...toKeep]
+    .filter((x) => !toRemove.has(x))
+    .sort((a, b) => {
+      return a - b;
+    });
+  const newZones: { top: number; bottom: number }[] = [];
+  let currentZone: { top: number; bottom: number } | undefined;
+  for (let x of finalElements) {
+    if (!currentZone) {
+      currentZone = { top: x, bottom: x };
+    } else if (x === currentZone.bottom + 1) {
+      currentZone.bottom = x;
+    } else {
+      newZones.push({ top: currentZone.top, bottom: currentZone.bottom });
+      currentZone = { top: x, bottom: x };
+    }
+  }
+  if (currentZone) {
+    newZones.push({ top: currentZone.top, bottom: currentZone.bottom });
+  }
+  return newZones;
+}
+
+/**
+ * Verify if ranges in two adjacent columns can be merged in one in one range,
+ * and if they can, merge them in the same range.
+ */
+function mergeColumns(
+  zonePerCol: {
+    col: number;
+    ranges: { top: number; bottom: number }[];
+  }[]
+) {
+  const orderedZones = zonePerCol.sort((a, b) => {
+    return a.col - b.col;
+  });
+  const finalZones: { top: number; left: number; right: number; bottom: number }[] = [];
+  let inProgressZones: { top: number; bottom: number; startCol: number }[] = [];
+  let currentCol = 0;
+  for (let index = 0; index <= orderedZones.length - 1; index++) {
+    let newInProgress: { top: number; bottom: number; startCol: number }[] = [];
+    if (currentCol + 1 === orderedZones[index].col) {
+      for (let z1 of orderedZones[index].ranges) {
+        let merged = false;
+        for (let z2 of inProgressZones) {
+          //extend existing zone with the adjacent col
+          if (z1.top == z2.top && z1.bottom == z2.bottom) {
+            newInProgress.push(z2);
+            merged = true;
+          }
+        }
+        // create new zone as it could not be merged with a previous one
+        if (!merged) {
+          newInProgress.push({ top: z1.top, bottom: z1.bottom, startCol: orderedZones[index].col });
+        }
+      }
+    } else {
+      // create new zone as it was not adjacent to the previous zones
+      newInProgress = orderedZones[index].ranges.map((zone) => {
+        return {
+          top: zone.top,
+          bottom: zone.bottom,
+          startCol: orderedZones[index].col,
+        };
+      });
+    }
+
+    //All the zones from inProgressZones that are not transferred in newInprogress
+    //are zones that were not extended and are therefore final.
+    const difference = inProgressZones.filter((x) => !newInProgress.includes(x));
+    for (let x of difference) {
+      finalZones.push({ top: x.top, bottom: x.bottom, left: x.startCol, right: currentCol });
+    }
+    currentCol = orderedZones[index].col;
+    inProgressZones = newInProgress;
+  }
+  //after the last iteration, the unfinished zones need to be finalized to.
+  for (let x of inProgressZones) {
+    finalZones.push({ top: x.top, bottom: x.bottom, left: x.startCol, right: currentCol });
+  }
+
+  return finalZones;
+}
+
+export function mapCellsInZone<T, U>(
+  zone: Zone,
+  sheet: Sheet,
+  callback: (cell: Cell) => T,
+  emptyCellValue: U = undefined as unknown as U
+): (T | U)[][] {
+  const { top, bottom, left, right } = zone;
+  const result: any[] = new Array(right - left + 1);
+  for (let c = left; c <= right; c++) {
+    let col: any[] = new Array(bottom - top + 1);
+    result[c - left] = col;
+    for (let r = top; r <= bottom; r++) {
+      let cell = sheet.rows[r].cells[c];
+      col[r - top] = cell ? callback(cell) : emptyCellValue;
+    }
+  }
+  return result;
+}

package/src/history.ts

@@ -0,0 +1,186 @@
+import {
+  CancelledReason,
+  Cell,
+  Command,
+  CommandHandler,
+  CommandResult,
+  Sheet,
+  Workbook,
+} from "./types/index";
+
+/**
+ * History Management System
+ *
+ * This file contains the code necessary to make the undo/redo feature work
+ * as expected.
+ */
+
+interface HistoryChange {
+  root: any;
+  path: (string | number)[];
+  before: any;
+  after: any;
+}
+
+type Step = HistoryChange[];
+
+/**
+ * Max Number of history steps kept in memory
+ */
+export const MAX_HISTORY_STEPS = 99;
+
+export interface WorkbookHistory {
+  updateState(path: (string | number)[], val: any): void;
+  updateLocalState(path: (string | number)[], val: any): void;
+  updateCell<T extends keyof Cell>(cell: Cell, key: T, value: Cell[T]): void;
+  updateSheet(sheet: Sheet, path: (string | number)[], value: any): void;
+}
+
+type WorkbookHistoryNonLocal = Omit<WorkbookHistory, "updateLocalState">;
+
+export class WHistory implements WorkbookHistoryNonLocal, CommandHandler {
+  private workbook: Workbook;
+  private current: Step | null = null;
+  private undoStack: Step[] = [];
+  private redoStack: Step[] = [];
+
+  constructor(workbook: Workbook) {
+    this.workbook = workbook;
+  }
+
+  // getters
+  canUndo(): boolean {
+    return this.undoStack.length > 0;
+  }
+
+  canRedo(): boolean {
+    return this.redoStack.length > 0;
+  }
+
+  allowDispatch(cmd: Command): CommandResult {
+    switch (cmd.type) {
+      case "UNDO":
+        return this.canUndo()
+          ? { status: "SUCCESS" }
+          : { status: "CANCELLED", reason: CancelledReason.EmptyUndoStack };
+      case "REDO":
+        return this.canRedo()
+          ? { status: "SUCCESS" }
+          : { status: "CANCELLED", reason: CancelledReason.EmptyRedoStack };
+    }
+    return { status: "SUCCESS" };
+  }
+
+  beforeHandle(cmd: Command) {
+    if (!this.current && cmd.type !== "REDO" && cmd.type !== "UNDO") {
+      this.current = [];
+    }
+  }
+
+  handle(cmd: Command) {
+    switch (cmd.type) {
+      case "UNDO":
+        this.undo();
+        break;
+      case "REDO":
+        this.redo();
+        break;
+    }
+  }
+
+  finalize() {
+    if (this.current && this.current.length) {
+      if (!this.isActiveSheet()) {
+        // We do not want to save the ACTIVATE_SHEET command if triggered
+        // standalone
+        this.undoStack.push(this.current);
+      }
+      this.redoStack = [];
+      this.current = null;
+      if (this.undoStack.length > MAX_HISTORY_STEPS) {
+        this.undoStack.shift();
+      }
+    }
+  }
+
+  isActiveSheet() {
+    return (
+      this.current &&
+      this.current.length === 1 &&
+      this.current[0].path.length === 1 &&
+      this.current[0].path[0] === "activeSheet"
+    );
+  }
+
+  undo() {
+    const step = this.undoStack.pop();
+    if (!step) {
+      return;
+    }
+    this.redoStack.push(step);
+    for (let i = step.length - 1; i >= 0; i--) {
+      let change = step[i];
+      this.applyChange(change, "before");
+    }
+  }
+
+  redo() {
+    const step = this.redoStack.pop();
+    if (!step) {
+      return;
+    }
+    this.undoStack.push(step);
+    for (let change of step) {
+      this.applyChange(change, "after");
+    }
+  }
+
+  private applyChange(change: HistoryChange, target: "before" | "after") {
+    let val = change.root as any;
+    let key = change.path[change.path.length - 1];
+    for (let p of change.path.slice(0, -1)) {
+      val = val[p];
+    }
+    if (change[target] === undefined) {
+      delete val[key];
+    } else {
+      val[key] = change[target];
+    }
+  }
+
+  updateStateFromRoot(root: any, path: (string | number)[], val: any) {
+    let value = root as any;
+    let key = path[path.length - 1];
+    for (let p of path.slice(0, -1)) {
+      value = value[p];
+    }
+    if (value[key] === val) {
+      return;
+    }
+    if (this.current) {
+      this.current.push({
+        root,
+        path,
+        before: value[key],
+        after: val,
+      });
+    }
+    if (val === undefined) {
+      delete value[key];
+    } else {
+      value[key] = val;
+    }
+  }
+
+  updateState(path: (string | number)[], val: any): void {
+    this.updateStateFromRoot(this.workbook, path, val);
+  }
+
+  updateCell<T extends keyof Cell>(cell: Cell, key: T, value: Cell[T]): void {
+    this.updateStateFromRoot(cell, [key], value);
+  }
+
+  updateSheet(sheet: Sheet, path: (string | number)[], value: any): void {
+    this.updateStateFromRoot(sheet, path, value);
+  }
+}

package/src/index.ts

@@ -0,0 +1,84 @@
+import {
+  BOTTOMBAR_HEIGHT,
+  DEFAULT_CELL_HEIGHT,
+  DEFAULT_CELL_WIDTH,
+  HEADER_HEIGHT,
+  HEADER_WIDTH,
+  MIN_COL_WIDTH,
+  MIN_ROW_HEIGHT,
+  SCROLLBAR_WIDTH,
+  TOPBAR_HEIGHT,
+} from "./constants";
+import { toBoolean, toNumber, toString } from "./functions/helpers";
+import { args, functionRegistry } from "./functions/index";
+import { formatDecimal, numberToLetters, toCartesian, toXC, toZone, uuidv4 } from "./helpers/index";
+import { pluginRegistry } from "./plugins/index";
+import {
+  autofillModifiersRegistry,
+  autofillRulesRegistry,
+  cellMenuRegistry,
+  colMenuRegistry,
+  createFullMenuItem,
+  rowMenuRegistry,
+  sheetMenuRegistry,
+  sidePanelRegistry,
+  topbarComponentRegistry,
+  topbarMenuRegistry,
+} from "./registries/index";
+
+/**
+ * We export here all entities that needs to be accessed publicly by Odoo.
+ *
+ * Note that the __info__ key is actually completed by the build process (see
+ * the rollup.config.js file)
+ */
+
+export const __info__ = {};
+export { BasePlugin } from "./base_plugin";
+export { Spreadsheet } from "./components/index";
+export { functionCache } from "./formulas/compiler";
+export { normalize } from "./formulas/index";
+export { astToFormula, parse } from "./formulas/parser";
+export { DEBUG as __DEBUG__ } from "./helpers/index";
+export { Model } from "./model";
+export { setTranslationMethod } from "./translation";
+
+export const SPREADSHEET_DIMENSIONS = {
+  MIN_ROW_HEIGHT,
+  MIN_COL_WIDTH,
+  HEADER_HEIGHT,
+  HEADER_WIDTH,
+  TOPBAR_HEIGHT,
+  BOTTOMBAR_HEIGHT,
+  DEFAULT_CELL_WIDTH,
+  DEFAULT_CELL_HEIGHT,
+  SCROLLBAR_WIDTH,
+};
+
+export const registries = {
+  autofillModifiersRegistry,
+  autofillRulesRegistry,
+  cellMenuRegistry,
+  colMenuRegistry,
+  functionRegistry,
+  pluginRegistry,
+  rowMenuRegistry,
+  sidePanelRegistry,
+  sheetMenuRegistry,
+  topbarMenuRegistry,
+  topbarComponentRegistry,
+};
+
+export const helpers = {
+  args,
+  toBoolean,
+  toNumber,
+  toString,
+  toXC,
+  toZone,
+  toCartesian,
+  numberToLetters,
+  createFullMenuItem,
+  uuidv4,
+  formatDecimal,
+};