@odoo/o-spreadsheet 14.0.1 → 15.0.0

package/src/data.ts

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

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

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

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

@@ -1,15 +0,0 @@
-/**
- * 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

@@ -1,52 +0,0 @@
-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 };
-}