@odoo/o-spreadsheet 14.0.0 → 14.0.1

package/src/data.ts

@@ -0,0 +1,149 @@
+import { uuidv4 } from "./helpers/index";
+import { SheetData, Workbook, WorkbookData } from "./types/index";
+
+/**
+ * This is the current state version number. It should be incremented each time
+ * a breaking change is made in the way the state is handled, and an upgrade
+ * function should be defined
+ */
+export const CURRENT_VERSION = 5;
+
+/**
+ * This function tries to load anything that could look like a valid
+ * workbookData object. It applies any migrations, if needed, and return a
+ * current, complete workbookData object.
+ *
+ * It also ensures that there is at least one sheet.
+ */
+export function load(data?: any): WorkbookData {
+  if (!data) {
+    return createEmptyWorkbookData();
+  }
+  data = Object.assign({}, data);
+
+  // apply migrations, if needed
+  if ("version" in data) {
+    if (data.version < CURRENT_VERSION) {
+      data = migrate(data);
+    }
+  }
+
+  // sanity check: try to fix missing fields/corrupted state by providing
+  // sensible default values
+  data = Object.assign(createEmptyWorkbookData(), data, { version: CURRENT_VERSION });
+  data.sheets = data.sheets.map((s, i) => Object.assign(createEmptySheet(`Sheet${i + 1}`), s));
+  if (!data.sheets.map((s) => s.id).includes(data.activeSheet)) {
+    data.activeSheet = data.sheets[0].id;
+  }
+
+  if (data.sheets.length === 0) {
+    data.sheets.push(createEmptySheet());
+  }
+  return data;
+}
+
+// -----------------------------------------------------------------------------
+// Migrations
+// -----------------------------------------------------------------------------
+
+interface Migration {
+  from: number;
+  to: number;
+  applyMigration(data: any): any;
+  description: string;
+}
+
+function migrate(data: any): WorkbookData {
+  const index = MIGRATIONS.findIndex((m) => m.from === data.version);
+  for (let i = index; i < MIGRATIONS.length; i++) {
+    data = MIGRATIONS[i].applyMigration(data);
+  }
+  return data;
+}
+
+const MIGRATIONS: Migration[] = [
+  {
+    description: "add the `activeSheet` field on data",
+    from: 1,
+    to: 2,
+    applyMigration(data: any): any {
+      if (data.sheets && data.sheets[0]) {
+        data.activeSheet = data.sheets[0].name;
+      }
+      return data;
+    },
+  },
+  {
+    description: "add an id field in each sheet",
+    from: 2,
+    to: 3,
+    applyMigration(data: any): any {
+      if (data.sheets && data.sheets.length) {
+        for (let sheet of data.sheets) {
+          sheet.id = sheet.id || sheet.name;
+        }
+      }
+      return data;
+    },
+  },
+  {
+    description: "activeSheet is now an id, not the name of a sheet",
+    from: 3,
+    to: 4,
+    applyMigration(data: any): any {
+      const activeSheet = data.sheets.find((s) => s.name === data.activeSheet);
+      data.activeSheet = activeSheet.id;
+      return data;
+    },
+  },
+  {
+    description: "add figures object in each sheets",
+    from: 4,
+    to: 5,
+    applyMigration(data: any): any {
+      for (let sheet of data.sheets) {
+        sheet.figures = sheet.figures || [];
+      }
+      return data;
+    },
+  },
+];
+
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+function createEmptySheet(name: string = "Sheet1"): SheetData {
+  return {
+    id: uuidv4(),
+    name,
+    colNumber: 26,
+    rowNumber: 100,
+    cells: {},
+    cols: {},
+    rows: {},
+    merges: [],
+    conditionalFormats: [],
+    figures: [],
+  };
+}
+
+export function createEmptyWorkbookData(): WorkbookData {
+  const data = {
+    version: CURRENT_VERSION,
+    sheets: [createEmptySheet("Sheet1")],
+    activeSheet: "",
+    entities: {},
+    styles: {},
+    borders: {},
+  };
+  data.activeSheet = data.sheets[0].id;
+  return data;
+}
+
+export function createEmptyWorkbook(): Workbook {
+  return {
+    visibleSheets: [],
+    sheets: {},
+    activeSheet: null as any,
+  };
+}

package/src/fonts.ts

@@ -0,0 +1,41 @@
+export interface Font {
+  key: string;
+  description: string;
+}
+
+export interface FontSize {
+  pt: number;
+  px: number;
+}
+
+export const fonts: Font[] = [
+  { key: "Arial", description: "Arial" },
+  { key: "Helvetica", description: "Helvetica" },
+  { key: "Courier New", description: "Courier New" },
+  { key: "Verdana", description: "Verdana" },
+  { key: "Lato", description: "Lato" },
+];
+
+export const fontSizes: FontSize[] = [
+  { pt: 7.5, px: 10 },
+  { pt: 8, px: 11 },
+  { pt: 9, px: 12 },
+  { pt: 10, px: 13 },
+  { pt: 10.5, px: 14 },
+  { pt: 11, px: 15 },
+  { pt: 12, px: 16 },
+  { pt: 14, px: 18.7 },
+  { pt: 15, px: 20 },
+  { pt: 16, px: 21.3 },
+  { pt: 18, px: 24 },
+  { pt: 22, px: 29.3 },
+  { pt: 24, px: 32 },
+  { pt: 26, px: 34.7 },
+  { pt: 36, px: 48 },
+];
+
+export const fontSizeMap: { [pt: number]: number } = {};
+
+for (let font of fontSizes) {
+  fontSizeMap[font.pt] = font.px;
+}

package/src/formulas/compiler.ts

@@ -0,0 +1,258 @@
+import { functionRegistry } from "../functions/index";
+import { _lt } from "../translation";
+import { Arg, CompiledFormula, NormalizedFormula } from "../types/index";
+import { AST, ASTAsyncFuncall, ASTFuncall, parse } from "./parser";
+
+const functions = functionRegistry.content;
+
+const OPERATOR_MAP = {
+  "=": "EQ",
+  "+": "ADD",
+  "-": "MINUS",
+  "*": "MULTIPLY",
+  "/": "DIVIDE",
+  ">=": "GTE",
+  "<>": "NE",
+  ">": "GT",
+  "<=": "LTE",
+  "<": "LT",
+  "^": "POWER",
+  "&": "CONCATENATE",
+};
+
+const UNARY_OPERATOR_MAP = {
+  "-": "UMINUS",
+  "+": "UPLUS",
+};
+
+// this cache contains all compiled function code, grouped by "structure". For
+// example, "=2*sum(A1:A4)" and "=2*sum(B1:B4)" are compiled into the same
+// structural function.
+//
+// It is only exported for testing purposes
+export const functionCache: { [key: string]: CompiledFormula } = {};
+
+// -----------------------------------------------------------------------------
+// COMPILER
+// -----------------------------------------------------------------------------
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+
+export function compile(str: NormalizedFormula): CompiledFormula {
+  // TODO: rename that 'str' variable. Doesn't make sense
+  let isAsync = false;
+
+  if (!functionCache[str.text]) {
+    const ast = parse(str.text);
+    let nextId = 1;
+    const code = [`// ${str.text}`];
+
+    if (ast.type === "BIN_OPERATION" && ast.value === ":") {
+      throw new Error(_lt("Invalid formula"));
+    }
+    if (ast.type === "UNKNOWN") {
+      throw new Error(_lt("Invalid formula"));
+    }
+
+    /**
+     * This function compile the function arguments. It is mostly straightforward,
+     * except that there is a non trivial transformation in one situation:
+     *
+     * If a function argument is asking for a range, and get a cell, we transform
+     * the cell value into a range. This allow the grid model to differentiate
+     * between a cell value and a non cell value.
+     */
+    function compileFunctionArgs(ast: ASTAsyncFuncall | ASTFuncall): string[] {
+      const functionDefinition = functions[ast.value.toUpperCase()];
+      let argDefinition: Arg;
+
+      const result: string[] = [];
+      const currentFunctionArguments = ast.args;
+
+      const isRepeating = functionDefinition.args.length
+        ? functionDefinition.args[functionDefinition.args.length - 1].repeating
+        : false;
+      let minArg = 0;
+      let maxArg = isRepeating ? Infinity : functionDefinition.args.length;
+      for (let arg of functionDefinition.args) {
+        if (!arg.optional) {
+          minArg++;
+        }
+      }
+      if (currentFunctionArguments.length < minArg || currentFunctionArguments.length > maxArg) {
+        throw new Error(
+          _lt(
+            "Invalid number of arguments for the %s function. Expected %s, but got %s instead.",
+            ast.value.toUpperCase(),
+            functionDefinition.args.length.toString(),
+            currentFunctionArguments.length.toString()
+          )
+        );
+      }
+      for (let i = 0; i < currentFunctionArguments.length; i++) {
+        const arg = currentFunctionArguments[i];
+        argDefinition = functionDefinition.args[i] || argDefinition!;
+        const isLazy = argDefinition && argDefinition.lazy;
+        const types = (argDefinition && argDefinition.type) || [];
+        const hasRange = types.some(
+          (t) =>
+            t === "RANGE" ||
+            t === "RANGE<BOOLEAN>" ||
+            t === "RANGE<DATE>" ||
+            t === "RANGE<NUMBER>" ||
+            t === "RANGE<STRING>"
+        );
+        const isRangeOnly = types.every(
+          (t) =>
+            t === "RANGE" ||
+            t === "RANGE<BOOLEAN>" ||
+            t === "RANGE<DATE>" ||
+            t === "RANGE<NUMBER>" ||
+            t === "RANGE<STRING>"
+        );
+        if (isRangeOnly && arg.type !== "REFERENCE") {
+          throw new Error(
+            _lt(
+              "Function %s expects the parameter %s to be reference to a cell or range, not a %s.",
+              ast.value.toUpperCase(),
+              (i + 1).toString(),
+              arg.type.toLowerCase().replace("normalized_", "")
+            )
+          );
+        }
+        if (
+          // a range of more than 1 cell
+          arg.type === "BIN_OPERATION" &&
+          arg.value === ":" &&
+          arg.left.value !== arg.right.value &&
+          !hasRange
+        ) {
+          throw new Error(
+            _lt(
+              "Function %s expects the parameter %s to be a single value or a single cell reference, not a range.",
+              ast.value.toUpperCase(),
+              (i + 1).toString()
+            )
+          );
+        }
+        let argValue = compileAST(arg, isLazy, hasRange, {
+          functionName: ast.value.toUpperCase(),
+          paramIndex: i + 1,
+        });
+        result.push(argValue);
+      }
+      return result;
+    }
+
+    /**
+     * This function compiles all the information extracted by the parser into an
+     * executable code for the evaluation of the cells content. It uses a cache to
+     * not reevaluate identical code structures.
+     *
+     * The function is sensitive to parameter “isLazy”. It may vary when compiling
+     * function arguments:
+     *
+     * - isLazy: In some cases the function arguments does not need to be
+     * evaluated before entering the functions. For example the IF function might
+     * take invalid arguments that do not need to be evaluate and thus should not
+     * create an error. For this we have lazy arguments.
+     *
+     */
+
+    function compileAST(
+      ast: AST,
+      isLazy = false,
+      hasRange = false,
+      referenceVerification: {
+        functionName?: string;
+        paramIndex?: number;
+      } = {}
+    ): string {
+      let id, left, right, args, fnName, statement;
+      if (ast.debug) {
+        code.push("debugger;");
+      }
+      switch (ast.type) {
+        case "BOOLEAN":
+        case "NUMBER": // probably dead case
+        case "STRING": // probably dead case
+          id = nextId++;
+          statement = ast.value;
+          break;
+        case "NORMALIZED_NUMBER":
+        case "NORMALIZED_STRING":
+          id = nextId++;
+          statement = `deps[${ast.value}]`;
+          break;
+        case "REFERENCE":
+          const referenceText = str.dependencies[ast.value];
+          if (!referenceText) {
+            id = nextId++;
+            statement = `null`;
+            break;
+          }
+          id = nextId++;
+          if (hasRange) {
+            statement = `range(${ast.value}, deps, sheetId)`;
+          } else {
+            statement = `ref(${ast.value}, deps, sheetId,
+              "${referenceVerification.functionName}", ${referenceVerification.paramIndex})`;
+          }
+          break;
+        case "FUNCALL":
+          id = nextId++;
+          args = compileFunctionArgs(ast);
+          fnName = ast.value.toUpperCase();
+          code.push(`ctx.__lastFnCalled = '${fnName}'`);
+          statement = `ctx['${fnName}'](${args})`;
+          break;
+        case "ASYNC_FUNCALL":
+          id = nextId++;
+          isAsync = true;
+          args = compileFunctionArgs(ast);
+          fnName = ast.value.toUpperCase();
+          code.push(`ctx.__lastFnCalled = '${fnName}'`);
+          statement = `await ctx['${fnName}'](${args})`;
+          break;
+        case "UNARY_OPERATION":
+          id = nextId++;
+          right = compileAST(ast.right);
+          fnName = UNARY_OPERATOR_MAP[ast.value];
+          code.push(`ctx.__lastFnCalled = '${fnName}'`);
+          statement = `ctx['${fnName}']( ${right})`;
+          break;
+        case "BIN_OPERATION":
+          id = nextId++;
+          left = compileAST(ast.left);
+          right = compileAST(ast.right);
+          fnName = OPERATOR_MAP[ast.value];
+          code.push(`ctx.__lastFnCalled = '${fnName}'`);
+          statement = `ctx['${fnName}'](${left}, ${right})`;
+          break;
+        case "UNKNOWN":
+          if (!isLazy) {
+            return "null";
+          }
+          id = nextId++;
+          statement = `null`;
+          break;
+      }
+      code.push(`let _${id} = ` + (isLazy ? `()=> ` : ``) + statement);
+      return `_${id}`;
+    }
+    code.push(`return ${compileAST(ast)};`);
+
+    const Constructor = isAsync ? AsyncFunction : Function;
+    let baseFunction = new Constructor(
+      "deps", // the dependencies in the current formula
+      "sheetId", // the sheet the formula is currently evaluating
+      "ref", // a function to access a certain dependency at a given index
+      "range", // same as above, but guarantee that the result is in the form of a range
+      "ctx",
+      code.join("\n")
+    );
+    functionCache[str.text] = baseFunction;
+    functionCache[str.text].async = isAsync;
+  }
+
+  return functionCache[str.text];
+}

package/src/formulas/composer_tokenizer.ts

@@ -0,0 +1,70 @@
+import { Token } from ".";
+import { mergeSymbolsIntoRanges } from "./range_tokenizer";
+import { tokenize } from "./tokenizer";
+
+/**
+ * Enriched Token is used by the composer to add information on the tokens that
+ * are only needed during the edition of a formula.
+ *
+ * The information added are:
+ * - parenthesis matching
+ * - range detection (replaces the tokens that composes the range with 1 token)
+ * - length, start and end of each token
+ */
+
+export interface EnrichedToken extends Token {
+  start: number;
+  end: number;
+  length: number;
+  parenIndex?: number;
+}
+
+/**
+ * Add the following information on tokens:
+ * - length
+ * - start
+ * - end
+ */
+function enrichTokens(tokens: Token[]): EnrichedToken[] {
+  let current = 0;
+  return tokens.map((x) => {
+    const len = x.value.toString().length;
+    const token: EnrichedToken = Object.assign({}, x, {
+      start: current,
+      end: current + len,
+      length: len,
+    });
+    current = token.end;
+    return token;
+  });
+}
+
+/**
+ * add on each token the length, start and end
+ * also matches the opening to its closing parenthesis (using the same number)
+ */
+function mapParenthesis(tokens: EnrichedToken[]): EnrichedToken[] {
+  let maxParen = 1;
+  const stack: number[] = [];
+  return tokens.map((token) => {
+    if (token.type === "LEFT_PAREN") {
+      stack.push(maxParen);
+      token.parenIndex = maxParen;
+      maxParen++;
+    } else if (token.type === "RIGHT_PAREN") {
+      token.parenIndex = stack.pop();
+    }
+    return token;
+  });
+}
+
+/**
+ * Take the result of the tokenizer and transform it to be usable in the composer.
+ *
+ * @param formula
+ */
+export function composerTokenize(formula: string): EnrichedToken[] {
+  const tokens = tokenize(formula);
+
+  return mapParenthesis(enrichTokens(mergeSymbolsIntoRanges(tokens)));
+}

package/src/formulas/index.ts

@@ -0,0 +1,15 @@
+/**
+ * The formulas module provides all functionality related to manipulating
+ * formulas:
+ *
+ * - tokenization (transforming a string into a list of tokens)
+ * - parsing (same, but into an AST (Abstract Syntax Tree))
+ * - compiler (getting an executable function representing a formula)
+ */
+
+export { compile } from "./compiler";
+export { composerTokenize, EnrichedToken } from "./composer_tokenizer";
+export { normalize } from "./normalize";
+export { cellReference, parse, rangeReference } from "./parser";
+export { rangeTokenize } from "./range_tokenizer";
+export { Token, tokenize } from "./tokenizer";

package/src/formulas/normalize.ts

@@ -0,0 +1,52 @@
+import { parseNumber } from "../helpers/numbers";
+import { Dependencies, NormalizedFormula } from "../types";
+import { cellReference } from "./parser";
+import { rangeTokenize } from "./range_tokenizer";
+import { FORMULA_REF_IDENTIFIER } from "./tokenizer";
+
+/**
+ * parses a formula (as a string) into the same formula,
+ * but with the references to other cells as well as strings and numbers extracted
+ *
+ * =sum(a3:b1) + c3 --> =sum(|0|) + |1|
+ *
+ * = sum(a3, 5) --> =sum(|0|, |N1|)
+ *
+ * =CONCAT(CONCAT(1, "beta"), A1) --> =CONCAT(CONCAT(|N0|, |S1|), |2|)
+ *
+ * Strings and Numbers are marked with a prefix of their type (S and N) to be detected
+ * as their normalized form by the parser as they won't be processed like the references by the compiler.
+ *
+ * @param formula
+ */
+export function normalize(formula: string): NormalizedFormula {
+  const tokens = rangeTokenize(formula);
+
+  let references: Dependencies = [];
+
+  let noRefFormula = "".concat(
+    ...tokens.map<string>((token) => {
+      if (token.type === "SYMBOL" && cellReference.test(token.value)) {
+        const value = token.value.trim();
+        if (!references.includes(value)) {
+          references.push(value);
+        }
+        return `${FORMULA_REF_IDENTIFIER}${references.indexOf(value)}${FORMULA_REF_IDENTIFIER}`;
+      } else if (["STRING", "NUMBER"].includes(token.type)) {
+        const value =
+          token.type === "STRING"
+            ? token.value.slice(1).slice(0, token.value.length - 2)
+            : parseNumber(token.value);
+        if (!references.includes(value)) {
+          references.push(value);
+        }
+        return `${FORMULA_REF_IDENTIFIER}${token.type[0]}${references.indexOf(
+          value
+        )}${FORMULA_REF_IDENTIFIER}`;
+      } else {
+        return token.value;
+      }
+    })
+  );
+  return { text: noRefFormula, dependencies: references };
+}