@odoo/o-spreadsheet 17.4.0-alpha.7 → 17.4.0-alpha.9

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.4.0-alpha.7
- * @date 2024-06-21T08:42:22.370Z
- * @hash a99db9a
+ * @version 17.4.0-alpha.9
+ * @date 2024-06-26T11:09:20.284Z
+ * @hash 526be20
  */
 
 (function (exports, owl) {
@@ -1902,9 +1902,10 @@
           sortedValues[indexLow] * (indexSup - percentIndex));
   }
 
-  // define a mock translation function, when o-spreadsheet runs in standalone it doesn't translate any string
-  let _translate = (s) => s;
-  let _loaded = () => false;
+  const defaultTranslate = (s) => s;
+  const defaultLoaded = () => false;
+  let _translate = defaultTranslate;
+  let _loaded = defaultLoaded;
   function sprintf(s, ...values) {
       if (values.length === 1 && typeof values[0] === "object" && !(values[0] instanceof String)) {
           const valuesDict = values[0];
@@ -1916,7 +1917,8 @@
       return s;
   }
   /***
-   * Allow to inject a translation function from outside o-spreadsheet.
+   * Allow to inject a translation function from outside o-spreadsheet. This should be called before instantiating
+   * a model.
    * @param tfn the function that will do the translation
    * @param loaded a function that returns true when the translation is loaded
    */
@@ -1924,6 +1926,18 @@
       _translate = tfn;
       _loaded = loaded;
   }
+  /**
+   * If no translation function has been set, this will mark the translation are loaded.
+   *
+   * By default, the translations should not be set as loaded, otherwise top-level translated constants will never be
+   * translated. But if by the time the model is instantiated no custom translation function has been set, we can set
+   * the default translation function as loaded so o-spreadsheet can be run in standalone with no translations.
+   */
+  function setDefaultTranslationMethod() {
+      if (_translate === defaultTranslate && _loaded === defaultLoaded) {
+          _loaded = () => true;
+      }
+  }
   const _t = function (s, ...values) {
       if (!_loaded()) {
           return new LazyTranslatedString(s, values);
@@ -5619,18 +5633,12 @@
           return { borders };
       }
       paste(target, content, options) {
-          if (!content) {
-              return;
-          }
           const sheetId = target.sheetId;
-          if (options?.pasteOption === "asValue") {
-              return;
-          }
-          if (!("borders" in content) || !("zones" in target) || !target.zones.length) {
+          if (options.pasteOption === "asValue") {
               return;
           }
           const zones = target.zones;
-          if (!options?.isCutOperation) {
+          if (!options.isCutOperation) {
               this.pasteFromCopy(sheetId, zones, content.borders);
           }
           else {
@@ -6141,6 +6149,530 @@
       return localizedFormula;
   }
 
+  function boolAnd(args) {
+      let foundBoolean = false;
+      let acc = true;
+      conditionalVisitBoolean(args, (arg) => {
+          foundBoolean = true;
+          acc = acc && arg;
+          return acc;
+      });
+      return {
+          foundBoolean,
+          result: acc,
+      };
+  }
+  function boolOr(args) {
+      let foundBoolean = false;
+      let acc = false;
+      conditionalVisitBoolean(args, (arg) => {
+          foundBoolean = true;
+          acc = acc || arg;
+          return !acc;
+      });
+      return {
+          foundBoolean,
+          result: acc,
+      };
+  }
+
+  function sum(values, locale) {
+      return reduceNumbers(values, (acc, a) => acc + a, 0, locale);
+  }
+  function countUnique(args) {
+      return reduceAny(args, (acc, a) => (isDataNonEmpty(a) ? acc.add(a?.value) : acc), new Set()).size;
+  }
+
+  function assertSameNumberOfElements(...args) {
+      const dims = args[0].length;
+      args.forEach((arg, i) => assert(() => arg.length === dims, _t("[[FUNCTION_NAME]] has mismatched dimensions for argument %s (%s vs %s).", i.toString(), dims.toString(), arg.length.toString())));
+  }
+  function average(values, locale) {
+      let count = 0;
+      const sum = reduceNumbers(values, (acc, a) => {
+          count += 1;
+          return acc + a;
+      }, 0, locale);
+      assertNotZero(count);
+      return sum / count;
+  }
+  function countNumbers(values, locale) {
+      let count = 0;
+      for (let n of values) {
+          if (isMatrix(n)) {
+              for (let i of n) {
+                  for (let j of i) {
+                      if (typeof j.value === "number") {
+                          count += 1;
+                      }
+                  }
+              }
+          }
+          else {
+              const value = n?.value;
+              if (!isEvaluationError(value) &&
+                  (typeof value !== "string" || isNumber(value, locale) || parseDateTime(value, locale))) {
+                  count += 1;
+              }
+          }
+      }
+      return count;
+  }
+  function countAny(values) {
+      return reduceAny(values, (acc, a) => (a !== undefined && a.value !== null ? acc + 1 : acc), 0);
+  }
+  function max(values, locale) {
+      const result = reduceNumbers(values, (acc, a) => (acc < a ? a : acc), -Infinity, locale);
+      return result === -Infinity ? 0 : result;
+  }
+  function min(values, locale) {
+      const result = reduceNumbers(values, (acc, a) => (a < acc ? a : acc), Infinity, locale);
+      return result === Infinity ? 0 : result;
+  }
+
+  const pivotTimeAdapterRegistry = new Registry();
+  function pivotTimeAdapter(granularity) {
+      return pivotTimeAdapterRegistry.get(granularity);
+  }
+  /**
+   * The Time Adapter: Managing Time Periods for Pivot Functions
+   *
+   * Overview:
+   * A time adapter is responsible for managing time periods associated with pivot functions.
+   * Each type of period (day, week, month, quarter, etc.) has its own dedicated adapter.
+   * The adapter's primary role is to normalize period values between spreadsheet functions,
+   * and the pivot.
+   * By normalizing the period value, it can be stored consistently in the pivot.
+   *
+   * Normalization Process:
+   * When working with functions in the spreadsheet, the time adapter normalizes
+   * the provided period to facilitate accurate lookup of values in the pivot.
+   * For instance, if the spreadsheet function represents a day period as a number generated
+   * by the DATE function (DATE(2023, 12, 25)), the time adapter will normalize it accordingly.
+   *
+   */
+  /**
+   * Normalized value: "12/25/2023"
+   *
+   * Note: Those two format are equivalent:
+   * - "MM/dd/yyyy" (luxon format)
+   * - "mm/dd/yyyy" (spreadsheet format)
+   **/
+  const dayAdapter = {
+      normalizeFunctionValue(value) {
+          return toNumber(value, DEFAULT_LOCALE);
+      },
+      toValueAndFormat(normalizedValue, locale) {
+          return {
+              value: toNumber(normalizedValue, DEFAULT_LOCALE),
+              format: (locale ?? DEFAULT_LOCALE).dateFormat,
+          };
+      },
+      toFunctionValue(normalizedValue) {
+          const date = toNumber(normalizedValue, DEFAULT_LOCALE);
+          return `"${formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/dd/yyyy" })}"`;
+      },
+  };
+  /**
+   * normalizes day of month number
+   */
+  const dayOfMonthAdapter = {
+      normalizeFunctionValue(value) {
+          const day = toNumber(value, DEFAULT_LOCALE);
+          if (day < 1 || day > 31) {
+              throw new EvaluationError(_t("%s is not a valid day of month (it should be a number between 1 and 31)", day));
+          }
+          return day;
+      },
+      toValueAndFormat(normalizedValue) {
+          return {
+              value: toNumber(normalizedValue, DEFAULT_LOCALE),
+              format: "0",
+          };
+      },
+      toFunctionValue(normalizedValue) {
+          return `${normalizedValue}`;
+      },
+  };
+  /**
+   * Normalized value: "2/2023" for week 2 of 2023
+   */
+  const weekAdapter = {
+      normalizeFunctionValue(value) {
+          const [week, year] = toString(value).split("/");
+          return `${Number(week)}/${Number(year)}`;
+      },
+      toValueAndFormat(normalizedValue, locale) {
+          const [week, year] = normalizedValue.split("/");
+          return {
+              value: _t("W%(week)s %(year)s", { week, year }),
+          };
+      },
+      toFunctionValue(normalizedValue) {
+          return `"${normalizedValue}"`;
+      },
+  };
+  /**
+   * normalizes iso week number
+   */
+  const isoWeekNumberAdapter = {
+      normalizeFunctionValue(value) {
+          const isoWeek = toNumber(value, DEFAULT_LOCALE);
+          if (isoWeek < 0 || isoWeek > 53) {
+              throw new EvaluationError(_t("%s is not a valid week (it should be a number between 0 and 53)", isoWeek));
+          }
+          return isoWeek;
+      },
+      toValueAndFormat(normalizedValue) {
+          return {
+              value: toNumber(normalizedValue, DEFAULT_LOCALE),
+              format: "0",
+          };
+      },
+      toFunctionValue(normalizedValue) {
+          return `${normalizedValue}`;
+      },
+  };
+  /**
+   * normalized month value is a string formatted as "MM/yyyy" (luxon format)
+   * e.g. "01/2020" for January 2020
+   */
+  const monthAdapter = {
+      normalizeFunctionValue(value) {
+          const date = toNumber(value, DEFAULT_LOCALE);
+          return formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/yyyy" });
+      },
+      toValueAndFormat(normalizedValue) {
+          return {
+              value: toNumber(normalizedValue, DEFAULT_LOCALE),
+              format: "mmmm yyyy",
+          };
+      },
+      toFunctionValue(normalizedValue) {
+          return `"${normalizedValue}"`;
+      },
+  };
+  /**
+   * normalizes month number
+   */
+  const monthNumberAdapter = {
+      normalizeFunctionValue(value) {
+          const month = toNumber(value, DEFAULT_LOCALE);
+          if (month < 1 || month > 12) {
+              throw new EvaluationError(_t("%s is not a valid month (it should be a number between 1 and 12)", month));
+          }
+          return month;
+      },
+      toValueAndFormat(normalizedValue) {
+          return {
+              value: MONTHS[toNumber(normalizedValue, DEFAULT_LOCALE) - 1].toString(),
+              format: "0",
+          };
+      },
+      toFunctionValue(normalizedValue) {
+          return `${normalizedValue}`;
+      },
+  };
+  /**
+   * normalized quarter value is "quarter/year"
+   * e.g. "1/2020" for Q1 2020
+   */
+  const quarterAdapter = {
+      normalizeFunctionValue(value) {
+          const [quarter, year] = toString(value).split("/");
+          return `${quarter}/${year}`;
+      },
+      toValueAndFormat(normalizedValue) {
+          const [quarter, year] = normalizedValue.split("/");
+          return {
+              value: _t("Q%(quarter)s %(year)s", { quarter, year }),
+          };
+      },
+      toFunctionValue(normalizedValue) {
+          return `"${normalizedValue}"`;
+      },
+  };
+  /**
+   * normalizes quarter number
+   */
+  const quarterNumberAdapter = {
+      normalizeFunctionValue(value) {
+          const quarter = toNumber(value, DEFAULT_LOCALE);
+          if (quarter < 1 || quarter > 4) {
+              throw new EvaluationError(_t("%s is not a valid quarter (it should be a number between 1 and 4)", quarter));
+          }
+          return quarter;
+      },
+      toValueAndFormat(normalizedValue) {
+          return {
+              value: toNumber(normalizedValue, DEFAULT_LOCALE),
+              format: "0",
+          };
+      },
+      toFunctionValue(normalizedValue) {
+          return `${normalizedValue}`;
+      },
+  };
+  const yearAdapter = {
+      normalizeFunctionValue(value) {
+          return toNumber(value, DEFAULT_LOCALE);
+      },
+      toValueAndFormat(normalizedValue) {
+          return {
+              value: toNumber(normalizedValue, DEFAULT_LOCALE),
+              format: "0",
+          };
+      },
+      toFunctionValue(normalizedValue) {
+          return `${normalizedValue}`;
+      },
+  };
+  /**
+   * This function takes an adapter and wraps it with a null handler.
+   * null value means that the value is not set.
+   */
+  function nullHandlerDecorator(adapter) {
+      return {
+          normalizeFunctionValue(value) {
+              if (value === null) {
+                  return null;
+              }
+              return adapter.normalizeFunctionValue(value);
+          },
+          toValueAndFormat(normalizedValue, locale) {
+              if (normalizedValue === null) {
+                  return { value: _t("(Undefined)") }; //TODO Return NA ?
+              }
+              return adapter.toValueAndFormat(normalizedValue, locale);
+          },
+          toFunctionValue(normalizedValue) {
+              if (normalizedValue === null) {
+                  return "false"; //TODO Return NA ?
+              }
+              return adapter.toFunctionValue(normalizedValue);
+          },
+      };
+  }
+  pivotTimeAdapterRegistry
+      .add("day", nullHandlerDecorator(dayAdapter))
+      .add("week", nullHandlerDecorator(weekAdapter))
+      .add("month", nullHandlerDecorator(monthAdapter))
+      .add("quarter", nullHandlerDecorator(quarterAdapter))
+      .add("year", nullHandlerDecorator(yearAdapter))
+      .add("day_of_month", nullHandlerDecorator(dayOfMonthAdapter))
+      .add("iso_week_number", nullHandlerDecorator(isoWeekNumberAdapter))
+      .add("month_number", nullHandlerDecorator(monthNumberAdapter))
+      .add("quarter_number", nullHandlerDecorator(quarterNumberAdapter))
+      .add("year_number", nullHandlerDecorator(yearAdapter));
+
+  const AGGREGATOR_NAMES = {
+      count: _t("Count"),
+      count_distinct: _t("Count Distinct"),
+      bool_and: _t("Boolean And"),
+      bool_or: _t("Boolean Or"),
+      max: _t("Maximum"),
+      min: _t("Minimum"),
+      avg: _t("Average"),
+      sum: _t("Sum"),
+  };
+  const NUMBER_CHAR_AGGREGATORS = ["max", "min", "avg", "sum", "count_distinct", "count"];
+  const AGGREGATORS_BY_FIELD_TYPE = {
+      integer: NUMBER_CHAR_AGGREGATORS,
+      char: NUMBER_CHAR_AGGREGATORS,
+      boolean: ["count_distinct", "count", "bool_and", "bool_or"],
+  };
+  const AGGREGATORS = {};
+  for (const type in AGGREGATORS_BY_FIELD_TYPE) {
+      AGGREGATORS[type] = {};
+      for (const aggregator of AGGREGATORS_BY_FIELD_TYPE[type]) {
+          AGGREGATORS[type][aggregator] = AGGREGATOR_NAMES[aggregator];
+      }
+  }
+  const AGGREGATORS_FN = {
+      count: {
+          fn: (args) => countAny([args]),
+          format: () => "0",
+      },
+      count_distinct: {
+          fn: (args) => countUnique([args]),
+          format: () => "0",
+      },
+      bool_and: {
+          fn: (args) => boolAnd([args]).result,
+          format: () => undefined,
+      },
+      bool_or: {
+          fn: (args) => boolOr([args]).result,
+          format: () => undefined,
+      },
+      max: {
+          fn: (args, locale) => max([args], locale),
+          format: inferFormat,
+      },
+      min: {
+          fn: (args, locale) => min([args], locale),
+          format: inferFormat,
+      },
+      avg: {
+          fn: (args, locale) => average([args], locale),
+          format: inferFormat,
+      },
+      sum: {
+          fn: (args, locale) => sum([args], locale),
+          format: inferFormat,
+      },
+  };
+  /**
+   * Given an object of form {"1": {...}, "2": {...}, ...} get the maximum ID used
+   * in this object
+   * If the object has no keys, return 0
+   *
+   */
+  function getMaxObjectId(o) {
+      const keys = Object.keys(o);
+      if (!keys.length) {
+          return 0;
+      }
+      const nums = keys.map((id) => parseInt(id, 10));
+      const max = Math.max(...nums);
+      return max;
+  }
+  const ALL_PERIODS = {
+      year: _t("Year"),
+      quarter: _t("Quarter"),
+      month: _t("Month"),
+      week: _t("Week"),
+      day: _t("Day"),
+      year_number: _t("Year"),
+      quarter_number: _t("Quarter"),
+      month_number: _t("Month"),
+      iso_week_number: _t("Week"),
+      day_of_month: _t("Day of Month"),
+  };
+  const DATE_FIELDS = ["date", "datetime"];
+  /**
+   * Parse a dimension string into a pivot dimension definition.
+   * e.g "create_date:month" => { name: "create_date", granularity: "month" }
+   */
+  function parseDimension(dimension) {
+      const [name, granularity] = dimension.split(":");
+      if (granularity) {
+          return { name, granularity };
+      }
+      return { name };
+  }
+  function isDateField(field) {
+      return DATE_FIELDS.includes(field.type);
+  }
+  function generatePivotArgs(formulaId, domain, measure) {
+      const args = [formulaId];
+      if (measure) {
+          args.push(`"${measure}"`);
+      }
+      for (const { field, value, type } of domain) {
+          if (field === "measure") {
+              args.push(`"measure"`, `"${value}"`);
+              continue;
+          }
+          const { granularity } = parseDimension(field);
+          const formattedValue = toFunctionPivotValue(value, { type, granularity });
+          args.push(`"${field}"`, formattedValue);
+      }
+      return args;
+  }
+  /**
+   * Check if the fields in the domain part of
+   * a pivot function are valid according to the pivot definition.
+   * e.g. =PIVOT.VALUE(1,"revenue","country_id",...,"create_date:month",...,"source_id",...)
+   */
+  function areDomainArgsFieldsValid(dimensions, definition) {
+      let argIndex = 0;
+      let definitionIndex = 0;
+      const cols = definition.columns.map((col) => col.nameWithGranularity);
+      const rows = definition.rows.map((row) => row.nameWithGranularity);
+      while (dimensions[argIndex] !== undefined && dimensions[argIndex] === rows[definitionIndex]) {
+          argIndex++;
+          definitionIndex++;
+      }
+      definitionIndex = 0;
+      while (dimensions[argIndex] !== undefined && dimensions[argIndex] === cols[definitionIndex]) {
+          argIndex++;
+          definitionIndex++;
+      }
+      return dimensions.length === argIndex;
+  }
+  function createPivotFormula(formulaId, cell) {
+      switch (cell.type) {
+          case "HEADER":
+              return `=PIVOT.HEADER(${generatePivotArgs(formulaId, cell.domain).join(",")})`;
+          case "VALUE":
+              return `=PIVOT.VALUE(${generatePivotArgs(formulaId, cell.domain, cell.measure).join(",")})`;
+          case "MEASURE_HEADER":
+              return `=PIVOT.HEADER(${generatePivotArgs(formulaId, [
+                ...cell.domain,
+                { field: "measure", value: cell.measure, type: "char" },
+            ]).join(",")})`;
+      }
+      return "";
+  }
+  /**
+   * Parses the value defining a pivot group in a PIVOT formula
+   * e.g. given the following formula PIVOT.VALUE("1", "stage_id", "42", "status", "won"),
+   * the two group values are "42" and "won".
+   */
+  function toNormalizedPivotValue(dimension, groupValue) {
+      if (groupValue === null || groupValue === "null") {
+          return null;
+      }
+      const groupValueString = typeof groupValue === "boolean"
+          ? toString(groupValue).toLocaleLowerCase()
+          : toString(groupValue);
+      if (!pivotNormalizationValueRegistry.contains(dimension.type)) {
+          throw new EvaluationError(_t("Field %(field)s is not supported because of its type (%(type)s)", {
+              field: dimension.displayName,
+              type: dimension.type,
+          }));
+      }
+      // represents a field which is not set (=False server side)
+      if (groupValueString.toLowerCase() === "false") {
+          return false;
+      }
+      const normalizer = pivotNormalizationValueRegistry.get(dimension.type);
+      return normalizer(groupValueString, dimension.granularity);
+  }
+  function normalizeDateTime(value, granularity) {
+      if (!granularity) {
+          throw new Error("Missing granularity");
+      }
+      return pivotTimeAdapter(granularity).normalizeFunctionValue(value);
+  }
+  function toFunctionPivotValue(value, dimension) {
+      if (!pivotToFunctionValueRegistry.contains(dimension.type)) {
+          return `"${value}"`;
+      }
+      return pivotToFunctionValueRegistry.get(dimension.type)(value, dimension.granularity);
+  }
+  function toFunctionValueDateTime(value, granularity) {
+      if (!granularity) {
+          throw new Error("Missing granularity");
+      }
+      return pivotTimeAdapter(granularity).toFunctionValue(value);
+  }
+  const pivotNormalizationValueRegistry = new Registry();
+  pivotNormalizationValueRegistry
+      .add("date", normalizeDateTime)
+      .add("datetime", normalizeDateTime)
+      .add("integer", (value) => toNumber(value, DEFAULT_LOCALE))
+      .add("boolean", (value) => toBoolean(value))
+      .add("char", (value) => toString(value));
+  const pivotToFunctionValueRegistry = new Registry();
+  pivotToFunctionValueRegistry
+      .add("date", toFunctionValueDateTime)
+      .add("datetime", toFunctionValueDateTime)
+      .add("integer", (value) => `${toNumber(value, DEFAULT_LOCALE)}`)
+      .add("boolean", (value) => (toBoolean(value) ? "TRUE" : "FALSE"))
+      .add("char", (value) => `"${toString(value).replace(/"/g, '\\"')}"`);
+
   class CellClipboardHandler extends AbstractCellClipboardHandler {
       isCutAllowed(data) {
           if (data.zones.length !== 1) {
@@ -6149,40 +6681,48 @@
           return "Success" /* CommandResult.Success */;
       }
       copy(data) {
-          if (!("zones" in data) || !data.zones.length) {
-              return;
-          }
           const sheetId = data.sheetId;
-          const zones = data.zones;
-          if (!zones.length) {
-              return {
-                  cells: [[]],
-                  zones: [],
-                  sheetId,
-              };
-          }
           const { clippedZones, rowsIndexes, columnsIndexes } = data;
           const clippedCells = [];
+          const isCopyingOneCell = rowsIndexes.length == 1 && columnsIndexes.length == 1;
           for (let row of rowsIndexes) {
               let cellsInRow = [];
               for (let col of columnsIndexes) {
                   const position = { col, row, sheetId };
-                  const spreader = this.getters.getArrayFormulaSpreadingOn(position);
                   let cell = this.getters.getCell(position);
                   const evaluatedCell = this.getters.getEvaluatedCell(position);
-                  if (spreader && !deepEquals(spreader, position)) {
-                      const isSpreaderCopied = rowsIndexes.includes(spreader.row) && columnsIndexes.includes(spreader.col);
-                      const content = isSpreaderCopied
-                          ? ""
-                          : formatValue(evaluatedCell.value, { locale: this.getters.getLocale() });
-                      cell = {
-                          id: cell?.id || "",
-                          style: cell?.style,
-                          format: evaluatedCell.format,
-                          content,
-                          isFormula: false,
-                          parsedValue: evaluatedCell.value,
-                      };
+                  const pivotId = this.getters.getPivotIdFromPosition(position);
+                  const spreader = this.getters.getArrayFormulaSpreadingOn(position);
+                  if (pivotId) {
+                      if (!deepEquals(spreader, position) || !isCopyingOneCell) {
+                          const pivotCell = this.getters.getPivotCellFromPosition(position);
+                          const formulaPivotId = this.getters.getPivotFormulaId(pivotId);
+                          const pivotFormula = createPivotFormula(formulaPivotId, pivotCell);
+                          cell = {
+                              id: cell?.id || "",
+                              style: cell?.style,
+                              format: evaluatedCell.format,
+                              content: pivotFormula,
+                              isFormula: false,
+                              parsedValue: evaluatedCell.value,
+                          };
+                      }
+                  }
+                  else {
+                      if (spreader && !deepEquals(spreader, position)) {
+                          const isSpreaderCopied = rowsIndexes.includes(spreader.row) && columnsIndexes.includes(spreader.col);
+                          const content = isSpreaderCopied
+                              ? ""
+                              : formatValue(evaluatedCell.value, { locale: this.getters.getLocale() });
+                          cell = {
+                              id: cell?.id || "",
+                              style: cell?.style,
+                              format: evaluatedCell.format,
+                              content,
+                              isFormula: false,
+                              parsedValue: evaluatedCell.value,
+                          };
+                      }
                   }
                   cellsInRow.push({
                       cell,
@@ -6231,12 +6771,9 @@
        * Paste the clipboard content in the given target
        */
       paste(target, content, options) {
-          if (!("cells" in content) || !("zones" in target) || !target.zones.length) {
-              return;
-          }
           const zones = target.zones;
           const sheetId = target.sheetId;
-          if (!options?.isCutOperation) {
+          if (!options.isCutOperation) {
               this.pasteFromCopy(sheetId, zones, content.cells, options);
           }
           else {
@@ -6406,14 +6943,11 @@
           };
       }
       getPasteTarget(sheetId, target, content, options) {
-          if (!content?.copiedFigure || !content?.copiedChart) {
-              return { zones: [], sheetId };
-          }
           const newId = new UuidGenerator().uuidv4();
           return { zones: [], figureId: newId, sheetId };
       }
       paste(target, clippedContent, options) {
-          if (!clippedContent?.copiedFigure || !clippedContent?.copiedChart || !target.figureId) {
+          if (!target.figureId) {
               return;
           }
           const { zones, figureId } = target;
@@ -6437,7 +6971,7 @@
               size: { height, width },
               definition: copy.getDefinition(),
           });
-          if (options?.isCutOperation) {
+          if (options.isCutOperation) {
               this.dispatch("DELETE_FIGURE", {
                   sheetId: clippedContent.copiedChart.sheetId,
                   id: clippedContent.copiedFigure.id,
@@ -6479,15 +7013,12 @@
           return { cfRules };
       }
       paste(target, clippedContent, options) {
-          if (!clippedContent?.cfRules ||
-              options?.pasteOption === "asValue" ||
-              !("zones" in target) ||
-              !target.zones.length) {
+          if (options.pasteOption === "asValue") {
               return;
           }
           const zones = target.zones;
           const sheetId = target.sheetId;
-          if (!options?.isCutOperation) {
+          if (!options.isCutOperation) {
               this.pasteFromCopy(sheetId, zones, clippedContent.cfRules, options);
           }
           else {
@@ -6561,9 +7092,6 @@
   class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
       uuidGenerator = new UuidGenerator();
       copy(data) {
-          if (!data.zones.length) {
-              return;
-          }
           const { rowsIndexes, columnsIndexes } = data;
           const sheetId = data.sheetId;
           const dvRules = [];
@@ -6579,18 +7107,12 @@
           return { dvRules };
       }
       paste(target, clippedContent, options) {
-          if (!clippedContent?.dvRules) {
-              return;
-          }
-          if (options?.pasteOption) {
-              return;
-          }
-          if (!("zones" in target) || !target.zones.length) {
+          if (options.pasteOption) {
               return;
           }
           const zones = target.zones;
           const sheetId = target.sheetId;
-          if (!options?.isCutOperation) {
+          if (!options.isCutOperation) {
               this.pasteFromCopy(sheetId, zones, clippedContent.dvRules);
           }
           else {
@@ -6689,14 +7211,11 @@
           };
       }
       getPasteTarget(sheetId, target, content, options) {
-          if (!content?.copiedFigure || !content?.copiedImage) {
-              return { zones: [], sheetId };
-          }
           const newId = new UuidGenerator().uuidv4();
           return { sheetId, zones: [], figureId: newId };
       }
       paste(target, clippedContent, options) {
-          if (!clippedContent?.copiedFigure || !clippedContent?.copiedImage || !target.figureId) {
+          if (!target.figureId) {
               return;
           }
           const { zones, figureId } = target;
@@ -6720,7 +7239,7 @@
               size: { height, width },
               definition: copy,
           });
-          if (options?.isCutOperation) {
+          if (options.isCutOperation) {
               this.dispatch("DELETE_FIGURE", {
                   sheetId: clippedContent.sheetId,
                   id: clippedContent.copiedFigure.id,
@@ -6741,9 +7260,6 @@
 
   class MergeClipboardHandler extends AbstractCellClipboardHandler {
       copy(data) {
-          if (!data.zones.length) {
-              return;
-          }
           const sheetId = this.getters.getActiveSheetId();
           const { rowsIndexes, columnsIndexes } = data;
           const merges = [];
@@ -6761,10 +7277,7 @@
        * Paste the clipboard content in the given target
        */
       paste(target, content, options) {
-          if (!content.merges ||
-              options?.isCutOperation ||
-              !("zones" in target) ||
-              !target.zones.length) {
+          if (options.isCutOperation) {
               return;
           }
           this.pasteFromCopy(target.sheetId, target.zones, content.merges, options);
@@ -6820,9 +7333,6 @@
       copy(data) {
           const sheetId = data.sheetId;
           const { rowsIndexes, columnsIndexes, zones } = data;
-          if (!zones || !rowsIndexes.length || !columnsIndexes.length) {
-              return { tableCells: [[]], sheetId };
-          }
           const copiedTablesIds = new Set();
           const tableCells = [];
           for (let row of rowsIndexes) {
@@ -6878,12 +7388,9 @@
           };
       }
       paste(target, content, options) {
-          if (!content || !content.tableCells) {
-              return;
-          }
           const zones = target.zones;
           const sheetId = target.sheetId;
-          if (!options?.isCutOperation) {
+          if (!options.isCutOperation) {
               this.pasteFromCopy(sheetId, zones, content.tableCells, options);
           }
           else {
@@ -7776,486 +8283,6 @@
       };
   }
 
-  function boolAnd(args) {
-      let foundBoolean = false;
-      let acc = true;
-      conditionalVisitBoolean(args, (arg) => {
-          foundBoolean = true;
-          acc = acc && arg;
-          return acc;
-      });
-      return {
-          foundBoolean,
-          result: acc,
-      };
-  }
-  function boolOr(args) {
-      let foundBoolean = false;
-      let acc = false;
-      conditionalVisitBoolean(args, (arg) => {
-          foundBoolean = true;
-          acc = acc || arg;
-          return !acc;
-      });
-      return {
-          foundBoolean,
-          result: acc,
-      };
-  }
-
-  function sum(values, locale) {
-      return reduceNumbers(values, (acc, a) => acc + a, 0, locale);
-  }
-  function countUnique(args) {
-      return reduceAny(args, (acc, a) => (isDataNonEmpty(a) ? acc.add(a?.value) : acc), new Set()).size;
-  }
-
-  function assertSameNumberOfElements(...args) {
-      const dims = args[0].length;
-      args.forEach((arg, i) => assert(() => arg.length === dims, _t("[[FUNCTION_NAME]] has mismatched dimensions for argument %s (%s vs %s).", i.toString(), dims.toString(), arg.length.toString())));
-  }
-  function average(values, locale) {
-      let count = 0;
-      const sum = reduceNumbers(values, (acc, a) => {
-          count += 1;
-          return acc + a;
-      }, 0, locale);
-      assertNotZero(count);
-      return sum / count;
-  }
-  function countNumbers(values, locale) {
-      let count = 0;
-      for (let n of values) {
-          if (isMatrix(n)) {
-              for (let i of n) {
-                  for (let j of i) {
-                      if (typeof j.value === "number") {
-                          count += 1;
-                      }
-                  }
-              }
-          }
-          else {
-              const value = n?.value;
-              if (!isEvaluationError(value) &&
-                  (typeof value !== "string" || isNumber(value, locale) || parseDateTime(value, locale))) {
-                  count += 1;
-              }
-          }
-      }
-      return count;
-  }
-  function countAny(values) {
-      return reduceAny(values, (acc, a) => (a !== undefined && a.value !== null ? acc + 1 : acc), 0);
-  }
-  function max(values, locale) {
-      const result = reduceNumbers(values, (acc, a) => (acc < a ? a : acc), -Infinity, locale);
-      return result === -Infinity ? 0 : result;
-  }
-  function min(values, locale) {
-      const result = reduceNumbers(values, (acc, a) => (a < acc ? a : acc), Infinity, locale);
-      return result === Infinity ? 0 : result;
-  }
-
-  const pivotTimeAdapterRegistry = new Registry();
-  function pivotTimeAdapter(granularity) {
-      return pivotTimeAdapterRegistry.get(granularity);
-  }
-  /**
-   * The Time Adapter: Managing Time Periods for Pivot Functions
-   *
-   * Overview:
-   * A time adapter is responsible for managing time periods associated with pivot functions.
-   * Each type of period (day, week, month, quarter, etc.) has its own dedicated adapter.
-   * The adapter's primary role is to normalize period values between spreadsheet functions,
-   * and the pivot.
-   * By normalizing the period value, it can be stored consistently in the pivot.
-   *
-   * Normalization Process:
-   * When working with functions in the spreadsheet, the time adapter normalizes
-   * the provided period to facilitate accurate lookup of values in the pivot.
-   * For instance, if the spreadsheet function represents a day period as a number generated
-   * by the DATE function (DATE(2023, 12, 25)), the time adapter will normalize it accordingly.
-   *
-   */
-  /**
-   * Normalized value: "12/25/2023"
-   *
-   * Note: Those two format are equivalent:
-   * - "MM/dd/yyyy" (luxon format)
-   * - "mm/dd/yyyy" (spreadsheet format)
-   **/
-  const dayAdapter = {
-      normalizeFunctionValue(value) {
-          const date = toNumber(value, DEFAULT_LOCALE);
-          return formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/dd/yyyy" });
-      },
-      getFormat(locale) {
-          return (locale ?? DEFAULT_LOCALE).dateFormat;
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  /**
-   * normalizes day of month number
-   */
-  const dayOfMonthAdapter = {
-      normalizeFunctionValue(value) {
-          const day = toNumber(value, DEFAULT_LOCALE);
-          if (day < 1 || day > 31) {
-              throw new EvaluationError(_t("%s is not a valid day of month (it should be a number between 1 and 31)", day));
-          }
-          return day;
-      },
-      getFormat() {
-          return "0";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  /**
-   * Normalized value: "2/2023" for week 2 of 2023
-   */
-  const weekAdapter = {
-      normalizeFunctionValue(value) {
-          const [week, year] = value.split("/");
-          return `${Number(week)}/${Number(year)}`;
-      },
-      getFormat() {
-          return undefined;
-      },
-      formatValue(normalizedValue) {
-          const [week, year] = normalizedValue.split("/");
-          return _t("W%(week)s %(year)s", { week, year });
-      },
-      toCellValue(normalizedValue) {
-          return this.formatValue(normalizedValue);
-      },
-  };
-  /**
-   * normalizes iso week number
-   */
-  const isoWeekNumberAdapter = {
-      normalizeFunctionValue(value) {
-          const isoWeek = toNumber(value, DEFAULT_LOCALE);
-          if (isoWeek < 0 || isoWeek > 53) {
-              throw new EvaluationError(_t("%s is not a valid week (it should be a number between 0 and 53)", isoWeek));
-          }
-          return isoWeek;
-      },
-      getFormat() {
-          return "0";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  /**
-   * normalized month value is a string formatted as "MM/yyyy" (luxon format)
-   * e.g. "01/2020" for January 2020
-   */
-  const monthAdapter = {
-      normalizeFunctionValue(value) {
-          const date = toNumber(value, DEFAULT_LOCALE);
-          return formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/yyyy" });
-      },
-      getFormat() {
-          return "mmmm yyyy";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  /**
-   * normalizes month number
-   */
-  const monthNumberAdapter = {
-      normalizeFunctionValue(value) {
-          const month = toNumber(value, DEFAULT_LOCALE);
-          if (month < 1 || month > 12) {
-              throw new EvaluationError(_t("%s is not a valid month (it should be a number between 1 and 12)", month));
-          }
-          return month;
-      },
-      getFormat() {
-          return "0";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return MONTHS[toNumber(normalizedValue, DEFAULT_LOCALE) - 1].toString();
-      },
-  };
-  /**
-   * normalized quarter value is "quarter/year"
-   * e.g. "1/2020" for Q1 2020
-   */
-  const quarterAdapter = {
-      normalizeFunctionValue(value) {
-          const [quarter, year] = value.split("/");
-          return `${quarter}/${year}`;
-      },
-      getFormat() {
-          return undefined;
-      },
-      formatValue(normalizedValue) {
-          const [quarter, year] = normalizedValue.split("/");
-          return _t("Q%(quarter)s %(year)s", { quarter, year });
-      },
-      toCellValue(normalizedValue) {
-          return this.formatValue(normalizedValue);
-      },
-  };
-  /**
-   * normalizes quarter number
-   */
-  const quarterNumberAdapter = {
-      normalizeFunctionValue(value) {
-          const quarter = toNumber(value, DEFAULT_LOCALE);
-          if (quarter < 1 || quarter > 4) {
-              throw new EvaluationError(_t("%s is not a valid quarter (it should be a number between 1 and 4)", quarter));
-          }
-          return quarter;
-      },
-      getFormat() {
-          return "0";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  const yearAdapter = {
-      normalizeFunctionValue(value) {
-          return toNumber(value, DEFAULT_LOCALE);
-      },
-      getFormat() {
-          return "0";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          return formatValue(normalizedValue, { locale, format: "0" });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  pivotTimeAdapterRegistry
-      .add("day", dayAdapter)
-      .add("week", weekAdapter)
-      .add("month", monthAdapter)
-      .add("quarter", quarterAdapter)
-      .add("year", yearAdapter)
-      .add("day_of_month", dayOfMonthAdapter)
-      .add("iso_week_number", isoWeekNumberAdapter)
-      .add("month_number", monthNumberAdapter)
-      .add("quarter_number", quarterNumberAdapter)
-      .add("year_number", yearAdapter);
-
-  const AGGREGATOR_NAMES = {
-      count: _t("Count"),
-      count_distinct: _t("Count Distinct"),
-      bool_and: _t("Boolean And"),
-      bool_or: _t("Boolean Or"),
-      max: _t("Maximum"),
-      min: _t("Minimum"),
-      avg: _t("Average"),
-      sum: _t("Sum"),
-  };
-  const NUMBER_CHAR_AGGREGATORS = ["max", "min", "avg", "sum", "count_distinct", "count"];
-  const AGGREGATORS_BY_FIELD_TYPE = {
-      integer: NUMBER_CHAR_AGGREGATORS,
-      char: NUMBER_CHAR_AGGREGATORS,
-      boolean: ["count_distinct", "count", "bool_and", "bool_or"],
-  };
-  const AGGREGATORS = {};
-  for (const type in AGGREGATORS_BY_FIELD_TYPE) {
-      AGGREGATORS[type] = {};
-      for (const aggregator of AGGREGATORS_BY_FIELD_TYPE[type]) {
-          AGGREGATORS[type][aggregator] = AGGREGATOR_NAMES[aggregator];
-      }
-  }
-  const AGGREGATORS_FN = {
-      count: {
-          fn: (args) => countAny([args]),
-          format: () => "0",
-      },
-      count_distinct: {
-          fn: (args) => countUnique([args]),
-          format: () => "0",
-      },
-      bool_and: {
-          fn: (args) => boolAnd([args]).result,
-          format: () => undefined,
-      },
-      bool_or: {
-          fn: (args) => boolOr([args]).result,
-          format: () => undefined,
-      },
-      max: {
-          fn: (args, locale) => max([args], locale),
-          format: inferFormat,
-      },
-      min: {
-          fn: (args, locale) => min([args], locale),
-          format: inferFormat,
-      },
-      avg: {
-          fn: (args, locale) => average([args], locale),
-          format: inferFormat,
-      },
-      sum: {
-          fn: (args, locale) => sum([args], locale),
-          format: inferFormat,
-      },
-  };
-  function makePivotFormulaFromPivotCell(pivotFormulaId, pivotCell) {
-      switch (pivotCell.type) {
-          case "HEADER":
-              return makePivotFormula("PIVOT.HEADER", [pivotFormulaId, ...flatPivotDomain(pivotCell.domain)].filter(isDefined));
-          case "MEASURE_HEADER":
-              return makePivotFormula("PIVOT.HEADER", [pivotFormulaId, ...flatPivotDomain(pivotCell.domain), "measure", pivotCell.measure].filter(isDefined));
-          case "VALUE":
-              return makePivotFormula("PIVOT.VALUE", [pivotFormulaId, pivotCell.measure, ...flatPivotDomain(pivotCell.domain)].filter(isDefined));
-          case "EMPTY":
-              return "";
-      }
-  }
-  /**
-   * Build a pivot formula expression
-   */
-  function makePivotFormula(formula, args) {
-      return `=${formula}(${args
-        .map((arg) => {
-        const stringIsNumber = typeof arg == "string" && !isNaN(Number(arg)) && Number(arg).toString() === arg;
-        const convertToNumber = typeof arg == "number" || stringIsNumber;
-        return convertToNumber ? `${arg}` : `"${arg.toString().replace(/"/g, '\\"')}"`;
-    })
-        .join(",")})`;
-  }
-  /**
-   * Given an object of form {"1": {...}, "2": {...}, ...} get the maximum ID used
-   * in this object
-   * If the object has no keys, return 0
-   *
-   */
-  function getMaxObjectId(o) {
-      const keys = Object.keys(o);
-      if (!keys.length) {
-          return 0;
-      }
-      const nums = keys.map((id) => parseInt(id, 10));
-      const max = Math.max(...nums);
-      return max;
-  }
-  const ALL_PERIODS = {
-      year: _t("Year"),
-      quarter: _t("Quarter"),
-      month: _t("Month"),
-      week: _t("Week"),
-      day: _t("Day"),
-      year_number: _t("Year"),
-      quarter_number: _t("Quarter"),
-      month_number: _t("Month"),
-      iso_week_number: _t("Week"),
-      day_of_month: _t("Day of Month"),
-  };
-  const DATE_FIELDS = ["date", "datetime"];
-  /**
-   * Parse a dimension string into a pivot dimension definition.
-   * e.g "create_date:month" => { name: "create_date", granularity: "month" }
-   */
-  function parseDimension(dimension) {
-      const [name, granularity] = dimension.split(":");
-      if (granularity) {
-          return { name, granularity };
-      }
-      return { name };
-  }
-  function isDateField(field) {
-      return DATE_FIELDS.includes(field.type);
-  }
-  function toPivotDomain(domainStr) {
-      if (domainStr.length % 2 !== 0) {
-          throw new Error("Invalid domain: odd number of elements");
-      }
-      const domain = [];
-      for (let i = 0; i < domainStr.length - 1; i += 2) {
-          domain.push({ field: domainStr[i], value: domainStr[i + 1] });
-      }
-      return domain;
-  }
-  function flatPivotDomain(domain) {
-      return domain.flatMap((arg) => [arg.field, arg.value]);
-  }
-  /**
-   * Parses the value defining a pivot group in a PIVOT formula
-   * e.g. given the following formula PIVOT.VALUE("1", "stage_id", "42", "status", "won"),
-   * the two group values are "42" and "won".
-   */
-  function toNormalizedPivotValue(dimension, groupValue) {
-      if (groupValue === null || groupValue === "null") {
-          return null;
-      }
-      const groupValueString = typeof groupValue === "boolean"
-          ? toString(groupValue).toLocaleLowerCase()
-          : toString(groupValue);
-      if (!pivotNormalizationValueRegistry.contains(dimension.type)) {
-          throw new EvaluationError(_t("Field %(field)s is not supported because of its type (%(type)s)", {
-              field: dimension.displayName,
-              type: dimension.type,
-          }));
-      }
-      // represents a field which is not set (=False server side)
-      if (groupValueString === "false") {
-          return false;
-      }
-      const normalizer = pivotNormalizationValueRegistry.get(dimension.type);
-      return normalizer(groupValueString, dimension.granularity);
-  }
-  function normalizeDateTime(value, granularity) {
-      if (!granularity) {
-          throw "";
-      }
-      return pivotTimeAdapter(granularity).normalizeFunctionValue(value);
-  }
-  const pivotNormalizationValueRegistry = new Registry();
-  pivotNormalizationValueRegistry
-      .add("date", normalizeDateTime)
-      .add("datetime", normalizeDateTime)
-      .add("integer", (value) => toNumber(value, DEFAULT_LOCALE))
-      .add("boolean", (value) => toBoolean(value))
-      .add("char", (value) => toString(value));
-
   /**
    * Change the reference types inside the given token, if the token represent a range or a cell
    *
@@ -9995,7 +10022,7 @@ stores.inject(MyMetaStore, storeInstance);
               const cell = this.getters.getCell(position);
               if (pivotId && pivotCell.type !== "EMPTY" && !cell?.isFormula) {
                   const formulaPivotId = this.getters.getPivotFormulaId(pivotId);
-                  const formula = makePivotFormulaFromPivotCell(formulaPivotId, pivotCell);
+                  const formula = createPivotFormula(formulaPivotId, pivotCell);
                   return formula.slice(1); // strip leading =
               }
           }
@@ -19087,10 +19114,9 @@ stores.inject(MyMetaStore, storeInstance);
       compute: function (formulaId, measureName, ...domainArgs) {
           const _pivotFormulaId = toString(formulaId);
           const _measure = toString(measureName);
-          const _domainArgs = domainArgs.map(toString);
           const pivotId = getPivotId(_pivotFormulaId, this.getters);
           assertMeasureExist(pivotId, _measure, this.getters);
-          assertDomainLength(_domainArgs);
+          assertDomainLength(domainArgs);
           const pivot = this.getters.getPivot(pivotId);
           const coreDefinition = this.getters.getPivotCoreDefinition(pivotId);
           addPivotDependencies(this, coreDefinition);
@@ -19098,15 +19124,14 @@ stores.inject(MyMetaStore, storeInstance);
           if (error) {
               return error;
           }
-          const domain = toPivotDomain(_domainArgs);
-          const { value, format } = pivot.getPivotCellValueAndFormat(_measure, domain);
-          if (!value && !this.getters.areDomainArgsFieldsValid(pivotId, domain)) {
+          if (!pivot.areDomainArgsFieldsValid(domainArgs)) {
               return {
                   value: CellErrorType.GenericError,
                   message: _t("Dimensions don't match the pivot definition"),
               };
           }
-          return { value, format };
+          const domain = pivot.parseArgsToPivotDomain(domainArgs);
+          return pivot.getPivotCellValueAndFormat(_measure, domain);
       },
   };
   const PIVOT_HEADER = {
@@ -19118,9 +19143,8 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (pivotId, ...domainArgs) {
           const _pivotFormulaId = toString(pivotId);
-          const _domainArgs = domainArgs.map(toString);
           const _pivotId = getPivotId(_pivotFormulaId, this.getters);
-          assertDomainLength(_domainArgs);
+          assertDomainLength(domainArgs);
           const pivot = this.getters.getPivot(_pivotId);
           const coreDefinition = this.getters.getPivotCoreDefinition(_pivotId);
           addPivotDependencies(this, coreDefinition);
@@ -19128,14 +19152,14 @@ stores.inject(MyMetaStore, storeInstance);
           if (error) {
               return error;
           }
-          const domain = toPivotDomain(_domainArgs);
-          const lastNode = domain.at(-1);
-          if (!this.getters.areDomainArgsFieldsValid(_pivotId, lastNode?.field === "measure" ? domain.slice(0, -1) : domain)) {
+          if (!pivot.areDomainArgsFieldsValid(domainArgs)) {
               return {
                   value: CellErrorType.GenericError,
                   message: _t("Dimensions don't match the pivot definition"),
               };
           }
+          const domain = pivot.parseArgsToPivotDomain(domainArgs);
+          const lastNode = domain.at(-1);
           if (lastNode?.field === "measure") {
               return pivot.getPivotMeasureValue(toString(lastNode.value), domain);
           }
@@ -19152,13 +19176,21 @@ stores.inject(MyMetaStore, storeInstance);
       description: _t("Get a pivot table."),
       args: [
           arg("pivot_id (string)", _t("ID of the pivot.")),
-          arg("row_count (number, optional, default=10000)", _t("number of rows")),
+          arg("row_count (number, optional)", _t("number of rows")),
           arg("include_total (boolean, default=TRUE)", _t("Whether to include total/sub-totals or not.")),
           arg("include_column_titles (boolean, default=TRUE)", _t("Whether to include the column titles or not.")),
+          arg("column_count (number, optional)", _t("number of columns")),
       ],
-      compute: function (pivotFormulaId, rowCount = { value: 10000 }, includeTotal = { value: true }, includeColumnHeaders = { value: true }) {
+      compute: function (pivotFormulaId, rowCount = { value: Number.MAX_VALUE }, includeTotal = { value: true }, includeColumnHeaders = { value: true }, columnCount = { value: Number.MAX_VALUE }) {
           const _pivotFormulaId = toString(pivotFormulaId);
           const _rowCount = toNumber(rowCount, this.locale);
+          if (_rowCount < 0) {
+              throw new EvaluationError(_t("The number of rows must be positive."));
+          }
+          const _columnCount = toNumber(columnCount, this.locale);
+          if (_columnCount < 0) {
+              throw new EvaluationError(_t("The number of columns must be positive."));
+          }
           const _includeColumnHeaders = toBoolean(includeColumnHeaders);
           const _includedTotal = toBoolean(includeTotal);
           const pivotId = getPivotId(_pivotFormulaId, this.getters);
@@ -19174,19 +19206,15 @@ stores.inject(MyMetaStore, storeInstance);
           const cells = table.getPivotCells(_includedTotal, _includeColumnHeaders);
           const headerRows = _includeColumnHeaders ? table.columns.length : 0;
           const pivotTitle = this.getters.getPivotDisplayName(pivotId);
-          if (_rowCount < 0) {
-              throw new EvaluationError(_t("The number of rows must be positive."));
-          }
-          const end = Math.min(headerRows + _rowCount, cells[0].length);
-          if (end === 0) {
+          const tableHeight = Math.min(headerRows + _rowCount, cells[0].length);
+          if (tableHeight === 0) {
               return [[{ value: pivotTitle }]];
           }
-          const tableWidth = cells.length;
-          const tableRows = range(0, end);
+          const tableWidth = Math.min(1 + _columnCount, cells.length);
           const result = [];
           for (const col of range(0, tableWidth)) {
               result[col] = [];
-              for (const row of tableRows) {
+              for (const row of range(0, tableHeight)) {
                   const pivotCell = cells[col][row];
                   switch (pivotCell.type) {
                       case "EMPTY":
@@ -21876,9 +21904,6 @@ stores.inject(MyMetaStore, storeInstance);
           const pivot = this.getters.getPivot(pivotId);
           pivot.init();
           const fields = pivot.getFields();
-          if (!fields) {
-              return [];
-          }
           const definition = this.getters.getPivotCoreDefinition(pivotId);
           return definition.measures
               .map((measure) => {
@@ -21918,9 +21943,6 @@ stores.inject(MyMetaStore, storeInstance);
           const pivot = this.getters.getPivot(pivotId);
           pivot.init();
           const fields = pivot.getFields();
-          if (!fields) {
-              return;
-          }
           const { columns, rows } = pivot.definition;
           let args = functionContext.args;
           if (functionContext?.parent.toUpperCase() === "PIVOT.VALUE") {
@@ -27069,7 +27091,7 @@ stores.inject(MyMetaStore, storeInstance);
       if (getZoneArea(zone) === 1 && topLeftCell?.content) {
           return {
               type: "scorecard",
-              title: { text: "" },
+              title: {},
               background: topLeftCell.style?.fillColor || undefined,
               keyValue: zoneToXc(zone),
               baselineMode: DEFAULT_SCORECARD_BASELINE_MODE,
@@ -27077,22 +27099,11 @@ stores.inject(MyMetaStore, storeInstance);
               baselineColorDown: DEFAULT_SCORECARD_BASELINE_COLOR_DOWN,
           };
       }
-      let title = "";
       const cellsInFirstRow = getters.getEvaluatedCellsInZone(sheetId, {
           ...dataSetZone,
           bottom: dataSetZone.top,
       });
       const dataSetsHaveTitle = !!cellsInFirstRow.find((cell) => cell.type !== CellValueType.empty && cell.type !== CellValueType.number);
-      if (dataSetsHaveTitle) {
-          const texts = cellsInFirstRow
-              .filter((cell) => cell.type !== CellValueType.error && cell.type !== CellValueType.empty)
-              .map((cell) => cell.formattedValue);
-          const lastElement = texts.splice(-1)[0];
-          title = texts.join(", ");
-          if (lastElement) {
-              title += (title ? " " + _t("and") + " " : "") + lastElement;
-          }
-      }
       let labelRangeXc;
       if (!singleColumn) {
           labelRangeXc = zoneToXc({
@@ -27105,7 +27116,7 @@ stores.inject(MyMetaStore, storeInstance);
       const labelRange = labelRangeXc ? getters.getRangeFromSheetXC(sheetId, labelRangeXc) : undefined;
       if (canChartParseLabels(labelRange, getters)) {
           return {
-              title: { text: title },
+              title: {},
               dataSets,
               labelsAsText: false,
               stacked: false,
@@ -27121,7 +27132,7 @@ stores.inject(MyMetaStore, storeInstance);
       if (singleColumn &&
           getData(getters, _dataSets[0]).every((e) => typeof e === "string" && !isEvaluationError(e))) {
           return {
-              title: { text: "" },
+              title: {},
               dataSets: [{ dataRange }],
               aggregated: true,
               labelRange: dataRange,
@@ -27131,7 +27142,7 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
       return {
-          title: { text: title },
+          title: {},
           dataSets,
           labelRange: labelRangeXc,
           type: "bar",
@@ -31674,7 +31685,7 @@ stores.inject(MyMetaStore, storeInstance);
       static template = "o-spreadsheet.ChartTitle";
       static components = { Section, ColorPickerWidget };
       static props = {
-          title: String,
+          title: { type: String, optional: true },
           updateTitle: Function,
           name: { type: String, optional: true },
           toggleItalic: { type: Function, optional: true },
@@ -31683,6 +31694,9 @@ stores.inject(MyMetaStore, storeInstance);
           updateColor: { type: Function, optional: true },
           style: { type: Object, optional: true },
       };
+      static defaultProps = {
+          title: "",
+      };
       openedEl = null;
       setup() {
           owl.useExternalListener(window, "click", this.onExternalClick);
@@ -34554,6 +34568,7 @@ stores.inject(MyMetaStore, storeInstance);
       currentSearchRegex = null;
       isSearchDirty = false;
       initialShowFormulaState;
+      preserveSelectedMatchIndex = false;
       // fixme: why do we make selectedMatchIndex on top of a selected
       // property in the matches?
       selectedMatchIndex = null;
@@ -34667,7 +34682,9 @@ stores.inject(MyMetaStore, storeInstance);
        * refresh the matches according to the current search options
        */
       refreshSearch(jumpToMatchSheet = true) {
-          this.selectedMatchIndex = null;
+          if (!this.preserveSelectedMatchIndex) {
+              this.selectedMatchIndex = null;
+          }
           this.findMatches();
           this.selectNextCell(Direction.current, jumpToMatchSheet);
       }
@@ -34766,10 +34783,16 @@ stores.inject(MyMetaStore, storeInstance);
           const selectedMatch = matches[nextIndex];
           // Switch to the sheet where the match is located
           if (jumpToMatchSheet && this.getters.getActiveSheetId() !== selectedMatch.sheetId) {
+              // We set `preserveSelectedMatchIndex` to true to avoid resetting the selected search
+              // index in the `refreshSearch` function when a new sheet is activated. The reason being
+              // that, when we automatically go back to previous sheet while performing a search, the
+              // search index is reset to the first occurrence each time.
+              this.preserveSelectedMatchIndex = true;
               this.model.dispatch("ACTIVATE_SHEET", {
                   sheetIdFrom: this.getters.getActiveSheetId(),
                   sheetIdTo: selectedMatch.sheetId,
               });
+              this.preserveSelectedMatchIndex = false;
               // We do not want to reset the selection at finalize in this case
               this.isSearchDirty = false;
           }
@@ -35410,6 +35433,10 @@ stores.inject(MyMetaStore, storeInstance);
               }
           });
       }
+      onClick(item) {
+          item.onClick();
+          this.popover.isOpen = false;
+      }
       get popoverProps() {
           const { x, y, width, height } = this.buttonRef.el.getBoundingClientRect();
           return {
@@ -35452,16 +35479,22 @@ stores.inject(MyMetaStore, storeInstance);
       static components = { CogWheelMenu, Section, EditableName };
       static props = {
           pivotId: String,
+          flipAxis: Function,
       };
       get cogWheelMenuItems() {
           return [
               {
-                  name: "Duplicate",
+                  name: _t("Flip axes"),
+                  icon: "fa-exchange",
+                  onClick: this.props.flipAxis,
+              },
+              {
+                  name: _t("Duplicate"),
                   icon: "fa-copy",
                   onClick: () => this.duplicatePivot(),
               },
               {
-                  name: "Delete",
+                  name: _t("Delete"),
                   icon: "fa-trash",
                   onClick: () => this.delete(),
               },
@@ -35658,9 +35691,10 @@ stores.inject(MyMetaStore, storeInstance);
       columns;
       rows;
       measures;
+      fieldsType;
       maxIndent;
       pivotCells = {};
-      constructor(columns, rows, measures) {
+      constructor(columns, rows, measures, fieldsType) {
           this.columns = columns.map((row) => {
               // offset in the pivot table
               // starts at 1 because the first column is the row title
@@ -35673,6 +35707,7 @@ stores.inject(MyMetaStore, storeInstance);
           });
           this.rows = rows;
           this.measures = measures;
+          this.fieldsType = fieldsType;
           this.maxIndent = Math.max(...this.rows.map((row) => row.indent));
       }
       /**
@@ -35719,7 +35754,7 @@ stores.inject(MyMetaStore, storeInstance);
               if (!domain) {
                   return EMPTY_PIVOT_CELL;
               }
-              const measure = domain.at(-1)?.value.toString() || "";
+              const measure = domain.at(-1)?.value?.toString() || "";
               return { type: "MEASURE_HEADER", domain: domain.slice(0, -1), measure };
           }
           else if (row <= colHeadersHeight - 1) {
@@ -35751,9 +35786,13 @@ stores.inject(MyMetaStore, storeInstance);
               return undefined;
           }
           for (let i = 0; i < pivotCol.fields.length; i++) {
+              const fieldWithGranularity = pivotCol.fields[i];
+              const { name, granularity } = parseDimension(fieldWithGranularity);
+              const type = this.fieldsType[name] || "char";
               domain.push({
-                  field: pivotCol.fields[i],
-                  value: pivotCol.values[i],
+                  type,
+                  field: fieldWithGranularity,
+                  value: toNormalizedPivotValue({ displayName: name, type, granularity }, pivotCol.values[i]),
               });
           }
           return domain;
@@ -35765,17 +35804,21 @@ stores.inject(MyMetaStore, storeInstance);
       getColMeasure(col) {
           const domain = this.getColHeaderDomain(col, this.columns.length - 1);
           const measure = domain?.at(-1)?.value;
-          if (measure === undefined) {
-              throw new Error("Measure isd missing");
+          if (measure === undefined || measure === null) {
+              throw new Error("Measure is missing");
           }
           return measure.toString();
       }
       getRowDomain(row) {
           const domain = [];
           for (let i = 0; i < this.rows[row].fields.length; i++) {
+              const fieldWithGranularity = this.rows[row].fields[i];
+              const { name, granularity } = parseDimension(fieldWithGranularity);
+              const type = this.fieldsType[name] || "char";
               domain.push({
-                  field: this.rows[row].fields[i],
-                  value: this.rows[row].values[i],
+                  type,
+                  field: fieldWithGranularity,
+                  value: toNormalizedPivotValue({ displayName: name, type, granularity }, this.rows[row].values[i]),
               });
           }
           return domain;
@@ -35785,6 +35828,7 @@ stores.inject(MyMetaStore, storeInstance);
               cols: this.columns,
               rows: this.rows,
               measures: this.measures,
+              fieldsType: this.fieldsType,
           };
       }
   }
@@ -35805,7 +35849,14 @@ stores.inject(MyMetaStore, storeInstance);
           indent: 0,
       });
       const measureNames = definition.measures.map((m) => m.name);
-      return new SpreadsheetPivotTable(cols, rows, measureNames);
+      const fieldsType = {};
+      for (const columns of definition.columns) {
+          fieldsType[columns.name] = columns.type;
+      }
+      for (const row of definition.rows) {
+          fieldsType[row.name] = row.type;
+      }
+      return new SpreadsheetPivotTable(cols, rows, measureNames, fieldsType);
   }
   // -----------------------------------------------------------------------------
   // ROWS
@@ -35981,41 +36032,42 @@ stores.inject(MyMetaStore, storeInstance);
       return dimension.order === "asc" ? a.localeCompare(b) : b.localeCompare(a);
   }
 
+  const NULL_SYMBOL = Symbol("NULL");
   function createDate(dimension, value, locale) {
       const granularity = dimension.granularity;
       if (!granularity || !(granularity in MAP_VALUE_DIMENSION_DATE)) {
           throw new Error(`Unknown date granularity: ${granularity}`);
       }
-      if (value === null) {
-          return null;
-      }
+      const keyInMap = typeof value === "number" || typeof value === "string" ? value : NULL_SYMBOL;
       if (!MAP_VALUE_DIMENSION_DATE[granularity].set.has(value)) {
           MAP_VALUE_DIMENSION_DATE[granularity].set.add(value);
-          const date = toJsDate(value, locale);
-          let number = 0;
-          switch (granularity) {
-              case "year_number":
-                  number = date.getFullYear();
-                  break;
-              case "quarter_number":
-                  number = Math.floor(date.getMonth() / 3) + 1;
-                  break;
-              case "month_number":
-                  number = date.getMonth() + 1;
-                  break;
-              case "iso_week_number":
-                  number = date.getIsoWeek();
-                  break;
-              case "day_of_month":
-                  number = date.getDate();
-                  break;
-              case "day":
-                  number = Math.floor(toNumber(value, locale));
-                  break;
+          let number = null;
+          if (typeof value === "number" || typeof value === "string") {
+              const date = toJsDate(value, locale);
+              switch (granularity) {
+                  case "year_number":
+                      number = date.getFullYear();
+                      break;
+                  case "quarter_number":
+                      number = Math.floor(date.getMonth() / 3) + 1;
+                      break;
+                  case "month_number":
+                      number = date.getMonth() + 1;
+                      break;
+                  case "iso_week_number":
+                      number = date.getIsoWeek();
+                      break;
+                  case "day_of_month":
+                      number = date.getDate();
+                      break;
+                  case "day":
+                      number = Math.floor(toNumber(value, locale));
+                      break;
+              }
           }
-          MAP_VALUE_DIMENSION_DATE[granularity].values[`${value}`] = toNormalizedPivotValue(dimension, number);
+          MAP_VALUE_DIMENSION_DATE[granularity].values[keyInMap] = toNormalizedPivotValue(dimension, number);
       }
-      return MAP_VALUE_DIMENSION_DATE[granularity].values[`${value}`];
+      return MAP_VALUE_DIMENSION_DATE[granularity].values[keyInMap];
   }
   /**
    * This map is used to cache the different values of a pivot date value
@@ -36197,6 +36249,25 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return undefined;
       }
+      areDomainArgsFieldsValid(args) {
+          let dimensions = args.filter((_, index) => index % 2 === 0).map(toString);
+          if (dimensions.length && dimensions.at(-1) === "measure") {
+              dimensions = dimensions.slice(0, -1);
+          }
+          return areDomainArgsFieldsValid(dimensions, this.definition);
+      }
+      parseArgsToPivotDomain(args) {
+          const domain = [];
+          for (let i = 0; i < args.length - 1; i += 2) {
+              const fieldWithGranularity = toString(args[i]);
+              const type = this.getTypeOfDimension(fieldWithGranularity);
+              const normalizedValue = fieldWithGranularity === "measure"
+                  ? toString(args[i + 1])
+                  : toNormalizedPivotValue(this.getDimension(fieldWithGranularity), args[i + 1]);
+              domain.push({ field: fieldWithGranularity, value: normalizedValue, type });
+          }
+          return domain;
+      }
       markAsDirtyForEvaluation() {
           this.needsReevaluation = true;
       }
@@ -36218,18 +36289,12 @@ stores.inject(MyMetaStore, storeInstance);
           const finalCell = cells[0]?.[dimension.nameWithGranularity];
           if (dimension.type === "date") {
               const adapter = pivotTimeAdapter(dimension.granularity);
-              return {
-                  value: lastNode.value !== "null"
-                      ? adapter.toCellValue(toNormalizedPivotValue(dimension, lastNode.value))
-                      : _t("(Undefined)"),
-                  format: adapter.getFormat(this.getters.getLocale()),
-              };
+              return adapter.toValueAndFormat(lastNode.value, this.getters.getLocale());
           }
           if (!finalCell) {
               return { value: "" };
           }
-          // Value can be null but stringified (e.g. an empty date, as for now every date is stringified)
-          if (finalCell.value === null || finalCell.value === `${null}`) {
+          if (finalCell.value === null) {
               return { value: _t("(Undefined)") };
           }
           return {
@@ -36280,14 +36345,24 @@ stores.inject(MyMetaStore, storeInstance);
       getFields() {
           return this.fields;
       }
+      getTypeOfDimension(fieldWithGranularity) {
+          if (fieldWithGranularity === "measure") {
+              return "char";
+          }
+          const { name } = parseDimension(fieldWithGranularity);
+          const type = this.fields[name]?.type;
+          if (!type) {
+              throw new Error(`Field ${name} does not exist`);
+          }
+          return type;
+      }
       filterDataEntriesFromDomain(dataEntries, domain) {
           return domain.reduce((current, acc) => this.filterDataEntriesFromDomainNode(current, acc), dataEntries);
       }
       filterDataEntriesFromDomainNode(dataEntries, domain) {
           const { field, value } = domain;
-          const dimension = this.getDimension(field);
-          return dataEntries.filter((entry) => `${entry[dimension.nameWithGranularity]?.value}` ===
-              `${toNormalizedPivotValue(dimension, value)}`);
+          const { nameWithGranularity } = this.getDimension(field);
+          return dataEntries.filter((entry) => entry[nameWithGranularity]?.value === value);
       }
       getDimension(nameWithGranularity) {
           return this.definition.getDimension(nameWithGranularity);
@@ -36392,7 +36467,7 @@ stores.inject(MyMetaStore, storeInstance);
               for (const entry of dataEntries) {
                   for (const dimension of dateDimensions) {
                       entry[dimension.nameWithGranularity] = {
-                          value: `${createDate(dimension, entry[dimension.name]?.value || null, this.getters.getLocale())}`,
+                          value: createDate(dimension, entry[dimension.name]?.value || null, this.getters.getLocale()),
                           type: entry[dimension.name]?.type || CellValueType.empty,
                           format: entry[dimension.name]?.format,
                       };
@@ -36439,11 +36514,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
       }
       get fields() {
-          const fields = this.pivot.getFields();
-          if (!fields) {
-              throw new Error("Fields not found");
-          }
-          return fields;
+          return this.pivot.getFields();
       }
       get pivot() {
           return this.getters.getPivot(this.pivotId);
@@ -36677,6 +36748,13 @@ stores.inject(MyMetaStore, storeInstance);
               this.store.applyUpdate();
           }
       }
+      flipAxis() {
+          const { rows, columns } = this.definition;
+          this.onDimensionsUpdated({
+              rows: columns,
+              columns: rows,
+          });
+      }
       onDimensionsUpdated(definition) {
           this.store.update(definition);
       }
@@ -51548,8 +51626,8 @@ stores.inject(MyMetaStore, storeInstance);
               case "INSERT_PIVOT": {
                   const { sheetId, col, row, pivotId, table } = cmd;
                   const position = { sheetId, col, row };
-                  const { cols, rows, measures } = table;
-                  const spTable = new SpreadsheetPivotTable(cols, rows, measures);
+                  const { cols, rows, measures, fieldsType } = table;
+                  const spTable = new SpreadsheetPivotTable(cols, rows, measures, fieldsType || {});
                   const formulaId = this.getPivotFormulaId(pivotId);
                   this.insertPivot(position, formulaId, spTable);
                   break;
@@ -51630,7 +51708,7 @@ stores.inject(MyMetaStore, storeInstance);
                       sheetId: position.sheetId,
                       col: position.col + col,
                       row: position.row + row,
-                      content: makePivotFormulaFromPivotCell(formulaId, pivotCell),
+                      content: createPivotFormula(formulaId, pivotCell),
                   });
               }
           }
@@ -54896,7 +54974,6 @@ stores.inject(MyMetaStore, storeInstance);
           "getPivotIdFromPosition",
           "getPivotCellFromPosition",
           "isPivotUnused",
-          "areDomainArgsFieldsValid",
           "isSpillPivotFormula",
       ];
       pivots = {};
@@ -54968,7 +55045,7 @@ stores.inject(MyMetaStore, storeInstance);
       getPivotIdFromPosition(position) {
           const cell = this.getters.getCorrespondingFormulaCell(position);
           if (cell && cell.isFormula) {
-              const pivotFunction = this.getFirstPivotFunction(cell.compiledFormula.tokens);
+              const pivotFunction = this.getFirstPivotFunction(position.sheetId, cell.compiledFormula.tokens);
               if (pivotFunction) {
                   const pivotId = pivotFunction.args[0]?.toString();
                   return pivotId && this.getters.getPivotId(pivotId);
@@ -54979,12 +55056,12 @@ stores.inject(MyMetaStore, storeInstance);
       isSpillPivotFormula(position) {
           const cell = this.getters.getCorrespondingFormulaCell(position);
           if (cell && cell.isFormula) {
-              const pivotFunction = this.getFirstPivotFunction(cell.compiledFormula.tokens);
+              const pivotFunction = this.getFirstPivotFunction(position.sheetId, cell.compiledFormula.tokens);
               return pivotFunction?.functionName === "PIVOT";
           }
           return false;
       }
-      getFirstPivotFunction(tokens) {
+      getFirstPivotFunction(sheetId, tokens) {
           const pivotFunction = getFirstPivotFunction(tokens);
           if (!pivotFunction) {
               return undefined;
@@ -55000,7 +55077,7 @@ stores.inject(MyMetaStore, storeInstance);
                   return argAst.value;
               }
               const argsString = astToFormula(argAst);
-              return this.getters.evaluateFormula(this.getters.getActiveSheetId(), argsString);
+              return this.getters.evaluateFormula(sheetId, argsString);
           });
           return { functionName, args: evaluatedArgs };
       }
@@ -55023,24 +55100,24 @@ stores.inject(MyMetaStore, storeInstance);
               return EMPTY_PIVOT_CELL;
           }
           const mainPosition = this.getters.getCellPosition(cell.id);
-          const result = this.getters.getFirstPivotFunction(cell.compiledFormula.tokens);
+          const result = this.getters.getFirstPivotFunction(position.sheetId, cell.compiledFormula.tokens);
           if (!result) {
               return EMPTY_PIVOT_CELL;
           }
           const { functionName, args } = result;
+          const formulaId = args[0];
+          if (!formulaId) {
+              return EMPTY_PIVOT_CELL;
+          }
+          const pivotId = this.getters.getPivotId(formulaId.toString());
+          if (!pivotId) {
+              return EMPTY_PIVOT_CELL;
+          }
+          const pivot = this.getPivot(pivotId);
+          if (!pivot.isValid()) {
+              return EMPTY_PIVOT_CELL;
+          }
           if (functionName === "PIVOT") {
-              const formulaId = args[0];
-              if (!formulaId) {
-                  return EMPTY_PIVOT_CELL;
-              }
-              const pivotId = this.getters.getPivotId(formulaId.toString());
-              if (!pivotId) {
-                  return EMPTY_PIVOT_CELL;
-              }
-              const pivot = this.getPivot(pivotId);
-              if (!pivot.isValid()) {
-                  return EMPTY_PIVOT_CELL;
-              }
               const includeTotal = args[2] === false ? false : undefined;
               const includeColumnHeaders = args[3] === false ? false : undefined;
               const pivotCells = pivot
@@ -55051,7 +55128,7 @@ stores.inject(MyMetaStore, storeInstance);
               return pivotCells[pivotCol][pivotRow];
           }
           if (functionName === "PIVOT.HEADER" && args.at(-2) === "measure") {
-              const domain = toPivotDomain(args.slice(1, -2).map((x) => `${x}`));
+              const domain = pivot.parseArgsToPivotDomain(args.slice(1, -2).map((value) => ({ value })));
               return {
                   type: "MEASURE_HEADER",
                   domain,
@@ -55059,15 +55136,17 @@ stores.inject(MyMetaStore, storeInstance);
               };
           }
           else if (functionName === "PIVOT.HEADER") {
+              const domain = pivot.parseArgsToPivotDomain(args.slice(1).map((value) => ({ value })));
               return {
                   type: "HEADER",
-                  domain: toPivotDomain(args.slice(1).map((x) => `${x}`)),
+                  domain,
               };
           }
           const [measure, ...domainArgs] = args.slice(1);
+          const domain = pivot.parseArgsToPivotDomain(domainArgs.map((value) => ({ value })));
           return {
               type: "VALUE",
-              domain: toPivotDomain(domainArgs.map((x) => `${x}`)),
+              domain,
               measure: measure?.toString() || "",
           };
       }
@@ -55077,32 +55156,6 @@ stores.inject(MyMetaStore, storeInstance);
       isPivotUnused(pivotId) {
           return this._getUnusedPivots().includes(pivotId);
       }
-      /**
-       * Check if the fields in the domain part of
-       * a pivot function are valid according to the pivot definition.
-       * e.g. =PIVOT.VALUE(1,"revenue","country_id",...,"create_date:month",...,"source_id",...)
-       */
-      areDomainArgsFieldsValid(pivotId, domain) {
-          const dimensions = domain
-              .map((node) => node.field)
-              .map((name) => (name.startsWith("#") ? name.slice(1) : name));
-          let argIndex = 0;
-          let definitionIndex = 0;
-          const pivot = this.getPivot(pivotId);
-          const definition = pivot.definition;
-          const cols = definition.columns.map((col) => col.nameWithGranularity);
-          const rows = definition.rows.map((row) => row.nameWithGranularity);
-          while (dimensions[argIndex] !== undefined && dimensions[argIndex] === rows[definitionIndex]) {
-              argIndex++;
-              definitionIndex++;
-          }
-          definitionIndex = 0;
-          while (dimensions[argIndex] !== undefined && dimensions[argIndex] === cols[definitionIndex]) {
-              argIndex++;
-              definitionIndex++;
-          }
-          return dimensions.length === argIndex;
-      }
       // ---------------------------------------------------------------------
       // Private
       // ---------------------------------------------------------------------
@@ -58585,32 +58638,32 @@ stores.inject(MyMetaStore, storeInstance);
           }
       }
       convertOSClipboardData(clipboardData) {
-          const handlers = clipboardHandlersRegistries.figureHandlers
-              .getAll()
-              .map((handler) => new handler(this.getters, this.dispatch));
-          clipboardHandlersRegistries.cellHandlers
-              .getAll()
-              .forEach((handler) => handlers.push(new handler(this.getters, this.dispatch)));
+          const handlers = this.selectClipboardHandlers({ figureId: true }).concat(this.selectClipboardHandlers({}));
           let copiedData = {};
-          for (const handler of handlers) {
+          for (const { handlerName, handler } of handlers) {
               const data = handler.convertOSClipboardData(clipboardData);
-              copiedData = { ...copiedData, ...data };
+              copiedData[handlerName] = data;
+              const minimalKeys = ["sheetId", "cells", "zones", "figureId"];
+              for (const key of minimalKeys) {
+                  if (data && key in data) {
+                      copiedData[key] = data[key];
+                  }
+              }
           }
           return copiedData;
       }
       selectClipboardHandlers(data) {
-          if ("figureId" in data) {
-              return clipboardHandlersRegistries.figureHandlers
-                  .getAll()
-                  .map((handler) => new handler(this.getters, this.dispatch));
-          }
-          return clipboardHandlersRegistries.cellHandlers
-              .getAll()
-              .map((handler) => new handler(this.getters, this.dispatch));
+          const handlersRegistry = "figureId" in data
+              ? clipboardHandlersRegistries.figureHandlers
+              : clipboardHandlersRegistries.cellHandlers;
+          return handlersRegistry.getKeys().map((handlerName) => {
+              const Handler = handlersRegistry.get(handlerName);
+              return { handlerName, handler: new Handler(this.getters, this.dispatch) };
+          });
       }
       isCutAllowedOn(zones) {
           const clipboardData = this.getClipboardData(zones);
-          for (const handler of this.selectClipboardHandlers(clipboardData)) {
+          for (const { handler } of this.selectClipboardHandlers(clipboardData)) {
               const result = handler.isCutAllowed(clipboardData);
               if (result !== "Success" /* CommandResult.Success */) {
                   return result;
@@ -58619,7 +58672,7 @@ stores.inject(MyMetaStore, storeInstance);
           return "Success" /* CommandResult.Success */;
       }
       isPasteAllowed(target, copiedData, options) {
-          for (const handler of this.selectClipboardHandlers(copiedData)) {
+          for (const { handler } of this.selectClipboardHandlers(copiedData)) {
               const result = handler.isPasteAllowed(this.getters.getActiveSheetId(), target, copiedData, {
                   ...options,
               });
@@ -58647,9 +58700,15 @@ stores.inject(MyMetaStore, storeInstance);
       copy(zones) {
           let copiedData = {};
           const clipboardData = this.getClipboardData(zones);
-          for (const handler of this.selectClipboardHandlers(clipboardData)) {
+          for (const { handlerName, handler } of this.selectClipboardHandlers(clipboardData)) {
               const data = handler.copy(clipboardData);
-              copiedData = { ...copiedData, ...data };
+              copiedData[handlerName] = data;
+              const minimalKeys = ["sheetId", "cells", "zones", "figureId"];
+              for (const key of minimalKeys) {
+                  if (data && key in data) {
+                      copiedData[key] = data[key];
+                  }
+              }
           }
           return copiedData;
       }
@@ -58665,8 +58724,12 @@ stores.inject(MyMetaStore, storeInstance);
               zones,
           };
           const handlers = this.selectClipboardHandlers(copiedData);
-          for (const handler of handlers) {
-              const currentTarget = handler.getPasteTarget(sheetId, zones, copiedData, options);
+          for (const { handlerName, handler } of handlers) {
+              const handlerData = copiedData[handlerName];
+              if (!handlerData) {
+                  continue;
+              }
+              const currentTarget = handler.getPasteTarget(sheetId, zones, handlerData, options);
               if (currentTarget.figureId) {
                   target.figureId = currentTarget.figureId;
               }
@@ -58682,7 +58745,12 @@ stores.inject(MyMetaStore, storeInstance);
           if (zone !== undefined) {
               this.addMissingDimensions(this.getters.getActiveSheetId(), zone.right - zone.left + 1, zone.bottom - zone.top + 1, zone.left, zone.top);
           }
-          handlers.forEach((handler) => handler.paste(target, copiedData, options));
+          handlers.forEach(({ handlerName, handler }) => {
+              const handlerData = copiedData[handlerName];
+              if (handlerData) {
+                  handler.paste(target, handlerData, options);
+              }
+          });
           if (!options?.selectTarget) {
               return;
           }
@@ -66802,6 +66870,7 @@ stores.inject(MyMetaStore, storeInstance);
           const start = performance.now();
           console.group("Model creation");
           super();
+          setDefaultTranslationMethod();
           stateUpdateMessages = repairInitialMessages(data, stateUpdateMessages);
           const workbookData = load(data, verboseImport);
           this.state = new StateObserver();
@@ -67297,6 +67366,7 @@ stores.inject(MyMetaStore, storeInstance);
       pivotSidePanelRegistry,
       pivotNormalizationValueRegistry,
       supportedPivotPositionalFormulaRegistry,
+      pivotToFunctionValueRegistry,
   };
   const helpers = {
       arg,
@@ -67342,7 +67412,6 @@ stores.inject(MyMetaStore, storeInstance);
       expandZoneOnInsertion,
       reduceZoneOnDeletion,
       unquote,
-      makePivotFormula,
       getMaxObjectId,
       getFunctionsFromTokens,
       getFirstPivotFunction,
@@ -67354,10 +67423,10 @@ stores.inject(MyMetaStore, storeInstance);
       insertTokenAfterLeftParenthesis,
       mergeContiguousZones,
       getPivotHighlights,
-      toPivotDomain,
-      flatPivotDomain,
       pivotTimeAdapter,
       UNDO_REDO_PIVOT_COMMANDS,
+      createPivotFormula,
+      areDomainArgsFieldsValid,
   };
   const links = {
       isMarkdownLink,
@@ -67488,9 +67557,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "17.4.0-alpha.7";
-  __info__.date = "2024-06-21T08:42:22.370Z";
-  __info__.hash = "a99db9a";
+  __info__.version = "17.4.0-alpha.9";
+  __info__.date = "2024-06-26T11:09:20.284Z";
+  __info__.hash = "526be20";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);