@odoo/o-spreadsheet 17.2.1 → 17.3.0-alpha.1

package/dist/o-spreadsheet.iife.js

@@ -3,9 +3,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.2.1
- * @date 2024-03-25T09:41:58.737Z
- * @hash f97284c
+ * @version 17.3.0-alpha.1
+ * @date 2024-03-25T09:43:36.072Z
+ * @hash 4095c41
  */
 
 (function (exports, owl) {
@@ -4202,6 +4202,10 @@
   function positionToZone(position) {
       return { left: position.col, right: position.col, top: position.row, bottom: position.row };
   }
+  /** Transform a zone into a zone with only its top-left position */
+  function zoneToTopLeft(zone) {
+      return { ...zone, right: zone.left, bottom: zone.top };
+  }
   function isFullRow(zone) {
       return zone.right === undefined;
   }
@@ -4241,6 +4245,16 @@
       }
       return set;
   }
+  function unionPositionsToZone(positions) {
+      const zone = { top: Infinity, left: Infinity, bottom: -Infinity, right: -Infinity };
+      for (const { col, row } of positions) {
+          zone.top = Math.min(zone.top, row);
+          zone.left = Math.min(zone.left, col);
+          zone.bottom = Math.max(zone.bottom, row);
+          zone.right = Math.max(zone.right, col);
+      }
+      return zone;
+  }
 
   class RangeImpl {
       getSheetSize;
@@ -5570,7 +5584,7 @@
                   const spreader = this.getters.getArrayFormulaSpreadingOn(position);
                   let cell = this.getters.getCell(position);
                   const evaluatedCell = this.getters.getEvaluatedCell(position);
-                  if (spreader) {
+                  if (spreader && !deepEquals(spreader, position)) {
                       const isSpreaderCopied = rowsIndexes.includes(spreader.row) && columnsIndexes.includes(spreader.col);
                       const content = isSpreaderCopied
                           ? ""
@@ -6217,19 +6231,25 @@
                       tableCellsInRow.push({});
                       continue;
                   }
+                  const coreTable = this.getters.getCoreTable(position);
+                  const tableZone = coreTable?.range.zone;
                   // Copy whole table
-                  if (zones.some((z) => isZoneInside(table.range.zone, z))) {
-                      copiedTablesIds.add(table.id);
+                  if (coreTable && tableZone && zones.some((z) => isZoneInside(tableZone, z))) {
+                      copiedTablesIds.add(coreTable.id);
                       const values = [];
-                      for (const col of range(table.range.zone.left, table.range.zone.right + 1)) {
-                          values.push(this.getters.getFilterHiddenValues({ sheetId, col, row: table.range.zone.top }));
+                      for (const col of range(tableZone.left, tableZone.right + 1)) {
+                          values.push(this.getters.getFilterHiddenValues({ sheetId, col, row: tableZone.top }));
                       }
                       tableCellsInRow.push({
-                          table: { filtersValues: values, range: table.range, config: table.config },
+                          table: {
+                              range: coreTable.range,
+                              config: coreTable.config,
+                              type: coreTable.type,
+                          },
                       });
                   }
                   // Copy only style of cell
-                  else {
+                  else if (table) {
                       tableCellsInRow.push({ style: this.getTableStyleToCopy(position) });
                   }
               }
@@ -6300,7 +6320,7 @@
       }
       pasteTableCell(sheetId, tableCell, position, options) {
           if (tableCell.table && !options?.pasteOption) {
-              const { range: tableRange, filtersValues } = tableCell.table;
+              const { range: tableRange } = tableCell.table;
               const zoneDims = zoneToDimension(tableRange.zone);
               const newTableZone = {
                   left: position.col,
@@ -6312,18 +6332,13 @@
                   sheetId: position.sheetId,
                   ranges: [this.getters.getRangeDataFromZone(sheetId, newTableZone)],
                   config: tableCell.table.config,
+                  tableType: tableCell.table.type,
               });
-              for (const i of range(0, filtersValues.length)) {
-                  this.dispatch("UPDATE_FILTER", {
-                      sheetId: position.sheetId,
-                      col: newTableZone.left + i,
-                      row: newTableZone.top,
-                      hiddenValues: filtersValues[i],
-                  });
-              }
           }
           // Do not paste table style if we're inside another table
-          if (!this.getters.getTable(position)) {
+          // We cannot check for dynamic tables, because at this point the paste can have changed the evaluation, and the
+          // dynamic tables are not yet computed
+          if (!this.getters.getCoreTable(position)) {
               if (tableCell.style?.style && options?.pasteOption !== "asValue") {
                   this.dispatch("UPDATE_CELL", { ...position, style: tableCell.style.style });
               }
@@ -7425,9 +7440,11 @@
           bandedColumns: _t("Banded columns"),
           automaticAutofill: _t("Automatically autofill formulas"),
           totalRow: _t("Total row"),
+          isDynamic: _t("Auto-adjust to formula result"),
       },
       Tooltips: {
           filterWithoutHeader: _t("Cannot have filters without a header row"),
+          isDynamic: _t("For tables based on array formulas only"),
       },
   };
 
@@ -22228,6 +22245,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       edit() {
           const { col, row } = this.props.cellPosition;
+          this.env.model.selection.selectCell(col, row);
           this.cellPopovers.open({ col, row }, "LinkEditor");
       }
       unlink() {
@@ -23344,13 +23362,20 @@ stores.inject(MyMetaStore, storeInstance);
    * If a single cell is selected, expand the selection to non-empty adjacent cells to create a table.
    */
   function interactiveCreateTable(env, sheetId, tableConfig) {
-      const selection = env.model.getters.getSelectedZones();
-      if (selection.length === 1 && getZoneArea(selection[0]) === 1) {
+      let target = env.model.getters.getSelectedZones();
+      let isDynamic = env.model.getters.canCreateDynamicTableOnZones(sheetId, target);
+      if (target.length === 1 && !isDynamic && getZoneArea(target[0]) === 1) {
           env.model.selection.selectTableAroundSelection();
+          target = env.model.getters.getSelectedZones();
+          isDynamic = env.model.getters.canCreateDynamicTableOnZones(sheetId, target);
       }
-      const target = env.model.getters.getSelectedZones();
       const ranges = target.map((zone) => env.model.getters.getRangeDataFromZone(sheetId, zone));
-      const result = env.model.dispatch("CREATE_TABLE", { ranges, sheetId, config: tableConfig });
+      const result = env.model.dispatch("CREATE_TABLE", {
+          ranges,
+          sheetId,
+          config: tableConfig,
+          tableType: isDynamic ? "dynamic" : "static",
+      });
       if (result.isCancelledBecause("TableOverlap" /* CommandResult.TableOverlap */)) {
           env.raiseError(TableTerms.Errors.TableOverlap);
       }
@@ -23798,9 +23823,13 @@ stores.inject(MyMetaStore, storeInstance);
   };
   const DELETE_SELECTED_TABLE = (env) => {
       const position = env.model.getters.getActivePosition();
+      const table = env.model.getters.getTable(position);
+      if (!table) {
+          return;
+      }
       env.model.dispatch("REMOVE_TABLE", {
           sheetId: position.sheetId,
-          target: [positionToZone(position)],
+          target: [table.range.zone],
       });
   };
   //------------------------------------------------------------------------------
@@ -30308,6 +30337,24 @@ stores.inject(MyMetaStore, storeInstance);
       const contentZone = { ...tableZone, top: tableZone.top + numberOfHeaders };
       return contentZone.top <= contentZone.bottom ? contentZone : undefined;
   }
+  function getTableTopLeft(table) {
+      const range = table.range;
+      return { row: range.zone.top, col: range.zone.left, sheetId: range.sheetId };
+  }
+  function createFilter(id, range, config, createRange) {
+      const zone = range.zone;
+      if (zone.left !== zone.right) {
+          throw new Error("Can only define a filter on a single column");
+      }
+      const filteredZone = { ...zone, top: zone.top + config.numberOfHeaders };
+      const filteredRange = createRange(range.sheetId, filteredZone);
+      return {
+          id,
+          rangeWithHeaders: range,
+          col: zone.left,
+          filteredRange: filteredZone.top > filteredZone.bottom ? undefined : filteredRange,
+      };
+  }
   function getComputedTableStyle(tableConfig, numberOfCols, numberOfRows) {
       return {
           borders: getAllTableBorders(tableConfig, numberOfCols, numberOfRows),
@@ -30745,6 +30792,11 @@ stores.inject(MyMetaStore, storeInstance);
       color: #ffffff;
       background: #d94b4b;
     }
+
+    .o-info-icon {
+      width: 14px;
+      height: 14px;
+    }
   }
 `;
   class TablePanel extends owl.Component {
@@ -30776,6 +30828,29 @@ stores.inject(MyMetaStore, storeInstance);
           const numberOfHeaders = hasHeaders ? 1 : 0;
           this.updateNumberOfHeaders(numberOfHeaders);
       }
+      updateTableIsDynamic(isDynamic) {
+          const newTableType = isDynamic ? "dynamic" : "forceStatic";
+          if (newTableType === this.props.table.type) {
+              return;
+          }
+          const uiTable = this.env.model.getters.getTable(getTableTopLeft(this.props.table));
+          if (!uiTable) {
+              return;
+          }
+          const sheetId = this.env.model.getters.getActiveSheetId();
+          const result = this.env.model.dispatch("UPDATE_TABLE", {
+              sheetId,
+              zone: this.props.table.range.zone,
+              newTableRange: uiTable.range.rangeData,
+              tableType: newTableType,
+          });
+          const updatedTable = this.env.model.getters.getCoreTable(getTableTopLeft(this.props.table));
+          if (result.isSuccessful && updatedTable) {
+              const newTableRange = updatedTable.range;
+              this.state.tableXc = this.env.model.getters.getRangeString(newTableRange, sheetId);
+              this.state.tableZoneErrors = [];
+          }
+      }
       onChangeNumberOfHeaders(ev) {
           const input = ev.target;
           const numberOfHeaders = parseInt(input.value);
@@ -30799,35 +30874,59 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const sheetId = this.env.model.getters.getActiveSheetId();
           this.state.tableXc = ranges[0];
+          const newTableRange = this.env.model.getters.getRangeFromSheetXC(sheetId, this.state.tableXc);
           this.state.tableZoneErrors = this.env.model.canDispatch("UPDATE_TABLE", {
               sheetId,
               zone: this.props.table.range.zone,
               newTableRange: this.env.model.getters.getRangeDataFromXc(sheetId, this.state.tableXc),
+              tableType: this.getNewTableType(newTableRange.zone),
           }).reasons;
       }
       onRangeConfirmed() {
           const sheetId = this.env.model.getters.getActiveSheetId();
-          const newRange = this.env.model.getters.getRangeFromSheetXC(sheetId, this.state.tableXc);
+          let newRange = this.env.model.getters.getRangeFromSheetXC(sheetId, this.state.tableXc);
+          if (getZoneArea(newRange.zone) === 1) {
+              const extendedZone = this.env.model.getters.getContiguousZone(sheetId, newRange.zone);
+              newRange = this.env.model.getters.getRangeFromZone(sheetId, extendedZone);
+          }
           const result = this.env.model.dispatch("UPDATE_TABLE", {
               sheetId,
               zone: this.props.table.range.zone,
               newTableRange: newRange.rangeData,
+              tableType: this.getNewTableType(newRange.zone),
           });
-          if (result.isSuccessful) {
-              const position = { col: newRange.zone.left, row: newRange.zone.top };
+          const position = { sheetId, col: newRange.zone.left, row: newRange.zone.top };
+          const updatedTable = this.env.model.getters.getCoreTable(position);
+          if (result.isSuccessful && updatedTable) {
+              const newTopLeft = getTableTopLeft(updatedTable);
               this.env.model.selection.selectZone({
-                  zone: positionToZone(position),
-                  cell: position,
+                  zone: positionToZone(newTopLeft),
+                  cell: newTopLeft,
               });
+              const newTableRange = updatedTable.range;
+              this.state.tableXc = this.env.model.getters.getRangeString(newTableRange, sheetId);
+          }
+          else {
+              const oldTableRange = this.props.table.range;
+              this.state.tableXc = this.env.model.getters.getRangeString(oldTableRange, sheetId);
           }
           this.state.tableZoneErrors = [];
-          this.state.tableXc = result.isSuccessful
-              ? this.state.tableXc
-              : this.env.model.getters.getRangeString(this.props.table.range, sheetId);
       }
       deleteTable() {
           const sheetId = this.env.model.getters.getActiveSheetId();
-          this.env.model.dispatch("REMOVE_TABLE", { sheetId, target: [this.props.table.range.zone] });
+          this.env.model.dispatch("REMOVE_TABLE", {
+              sheetId,
+              target: [this.props.table.range.zone],
+          });
+      }
+      getNewTableType(newTableZone) {
+          if (this.props.table.type === "forceStatic") {
+              return "forceStatic";
+          }
+          const sheetId = this.env.model.getters.getActiveSheetId();
+          return this.env.model.getters.canCreateDynamicTableOnZones(sheetId, [newTableZone])
+              ? "dynamic"
+              : "static";
       }
       get tableConfig() {
           return this.props.table.config;
@@ -30845,6 +30944,14 @@ stores.inject(MyMetaStore, storeInstance);
       get hasFilterCheckboxTooltip() {
           return this.canHaveFilters ? undefined : TableTerms.Tooltips.filterWithoutHeader;
       }
+      get canBeDynamic() {
+          const sheetId = this.env.model.getters.getActiveSheetId();
+          return (this.props.table.type === "dynamic" ||
+              this.env.model.getters.canCreateDynamicTableOnZones(sheetId, [this.props.table.range.zone]));
+      }
+      get dynamicTableTooltip() {
+          return TableTerms.Tooltips.isDynamic;
+      }
   }
 
   const sidePanelRegistry = new Registry();
@@ -30907,11 +31014,8 @@ stores.inject(MyMetaStore, storeInstance);
           if (!table) {
               return { isOpen: false };
           }
-          return {
-              isOpen: true,
-              props: { table },
-              key: table.id,
-          };
+          const coreTable = getters.getCoreTable(getTableTopLeft(table));
+          return { isOpen: true, props: { table: coreTable }, key: table.id };
       },
   });
 
@@ -31856,9 +31960,6 @@ stores.inject(MyMetaStore, storeInstance);
               this.assistantState.allowCellSelectionBehind = false;
           }, 2000);
       }
-      get formulaArgSeparator() {
-          return this.env.model.getters.getLocale().formulaArgSeparator + " ";
-      }
   }
 
   const functions$2 = functionRegistry.content;
@@ -32756,8 +32857,7 @@ stores.inject(MyMetaStore, storeInstance);
       };
       getFilterHeadersPositions() {
           const sheetId = this.env.model.getters.getActiveSheetId();
-          const headerPositions = this.env.model.getters.getFilterHeaders(sheetId);
-          return headerPositions.map((position) => ({ sheetId, ...position }));
+          return this.env.model.getters.getFilterHeaders(sheetId);
       }
   }
 
@@ -44826,22 +44926,12 @@ stores.inject(MyMetaStore, storeInstance);
   }
 
   class TablePlugin extends CorePlugin {
-      static getters = [
-          "getFilter",
-          "getFilters",
-          "getTable",
-          "getTables",
-          "getTablesInZone",
-          "getTablesOverlappingZones",
-          "getFilterId",
-          "getFilterHeaders",
-          "isFilterHeader",
-      ];
+      static getters = ["getCoreTable", "getCoreTables"];
       tables = {};
       adaptRanges(applyChange, sheetId) {
           const sheetIds = sheetId ? [sheetId] : this.getters.getSheetIds();
           for (const sheetId of sheetIds) {
-              for (const table of this.getTables(sheetId)) {
+              for (const table of this.getCoreTables(sheetId)) {
                   this.applyRangeChangeOnTable(sheetId, table, applyChange);
               }
           }
@@ -44857,15 +44947,16 @@ stores.inject(MyMetaStore, storeInstance);
                       ? "TableOverlap" /* CommandResult.TableOverlap */
                       : "Success" /* CommandResult.Success */, (cmd) => this.checkTableConfigUpdateIsValid(cmd.config));
               case "UPDATE_TABLE":
-                  const updatedTable = this.getTables(cmd.sheetId).find((table) => deepEquals(table.range.zone, cmd.zone));
+                  const updatedTable = this.getTableFromZone(cmd.sheetId, cmd.zone);
                   if (!updatedTable) {
                       return "TableNotFound" /* CommandResult.TableNotFound */;
                   }
                   return this.checkValidations(cmd, this.checkUpdatedTableZoneIsValid, (cmd) => this.checkTableConfigUpdateIsValid(cmd.config));
               case "ADD_MERGE":
-                  for (const merge of cmd.target) {
-                      for (const table of this.getTables(cmd.sheetId)) {
-                          if (overlap(table.range.zone, merge)) {
+                  for (const table of this.getCoreTables(cmd.sheetId)) {
+                      const tableZone = table.range.zone;
+                      for (const merge of cmd.target) {
+                          if (overlap(tableZone, merge)) {
                               return "MergeInTable" /* CommandResult.MergeInTable */;
                           }
                       }
@@ -44887,8 +44978,11 @@ stores.inject(MyMetaStore, storeInstance);
               }
               case "DUPLICATE_SHEET": {
                   const newTables = {};
-                  for (const table of this.getTables(cmd.sheetId)) {
-                      newTables[table.id] = this.copyTableForSheet(cmd.sheetIdTo, table);
+                  for (const table of this.getCoreTables(cmd.sheetId)) {
+                      newTables[table.id] =
+                          table.type === "dynamic"
+                              ? this.copyDynamicTableForSheet(cmd.sheetIdTo, table)
+                              : this.copyStaticTableForSheet(cmd.sheetIdTo, table);
                   }
                   this.history.update("tables", cmd.sheetIdTo, newTables);
                   break;
@@ -44899,14 +44993,17 @@ stores.inject(MyMetaStore, storeInstance);
                   const mergesInTarget = this.getters.getMergesInZone(cmd.sheetId, union.zone);
                   this.dispatch("REMOVE_MERGE", { sheetId: cmd.sheetId, target: mergesInTarget });
                   const id = this.uuidGenerator.uuidv4();
-                  const newTable = this.createTable(id, union, cmd.config || DEFAULT_TABLE_CONFIG);
+                  const config = cmd.config || DEFAULT_TABLE_CONFIG;
+                  const newTable = cmd.tableType === "dynamic"
+                      ? this.createDynamicTable(id, union, config)
+                      : this.createStaticTable(id, cmd.tableType, union, config);
                   this.history.update("tables", cmd.sheetId, newTable.id, newTable);
                   break;
               }
               case "REMOVE_TABLE": {
                   const tables = {};
-                  for (const table of this.getTables(cmd.sheetId)) {
-                      if (cmd.target.every((zone) => !intersection(zone, table.range.zone))) {
+                  for (const table of this.getCoreTables(cmd.sheetId)) {
+                      if (cmd.target.every((zone) => !intersection(table.range.zone, zone))) {
                           tables[table.id] = table;
                       }
                   }
@@ -44914,23 +45011,15 @@ stores.inject(MyMetaStore, storeInstance);
                   break;
               }
               case "UPDATE_TABLE": {
-                  const table = this.getTables(cmd.sheetId).find((table) => deepEquals(table.range.zone, cmd.zone));
-                  if (table) {
-                      const newTableRange = cmd.newTableRange
-                          ? this.getters.getRangeFromRangeData(cmd.newTableRange)
-                          : undefined;
-                      if (newTableRange) {
-                          const mergesInTarget = this.getters.getMergesInZone(cmd.sheetId, newTableRange.zone);
-                          this.dispatch("REMOVE_MERGE", { sheetId: cmd.sheetId, target: mergesInTarget });
-                      }
-                      const newTable = this.updateTable(table, newTableRange, cmd.config);
-                      this.history.update("tables", cmd.sheetId, table.id, newTable);
-                  }
+                  this.updateTable(cmd);
                   break;
               }
               case "UPDATE_CELL": {
                   const sheetId = cmd.sheetId;
-                  for (const table of this.getTables(sheetId)) {
+                  for (const table of this.getCoreTables(sheetId)) {
+                      if (table.type === "dynamic") {
+                          continue;
+                      }
                       const direction = this.canUpdateCellCmdExtendTable(cmd, table);
                       if (direction === "down") {
                           this.extendTableDown(sheetId, table);
@@ -44954,62 +45043,24 @@ stores.inject(MyMetaStore, storeInstance);
               }
           }
       }
-      getFilters(sheetId) {
-          return this.getTables(sheetId)
-              .filter((table) => table.config.hasFilters)
-              .map((table) => table.filters)
-              .flat();
-      }
-      getTables(sheetId) {
+      getCoreTables(sheetId) {
           return this.tables[sheetId] ? Object.values(this.tables[sheetId]).filter(isDefined$1) : [];
       }
-      getFilter(position) {
-          const table = this.getTable(position);
-          if (!table || !table.config.hasFilters) {
-              return undefined;
-          }
-          return table.filters.find((filter) => filter.col === position.col);
-      }
-      getFilterId(position) {
-          return this.getFilter(position)?.id;
-      }
-      getTable({ sheetId, col, row }) {
-          return this.getTables(sheetId).find((table) => isInside(col, row, table.range.zone));
-      }
-      /** Get the filter tables that are fully inside the given zone */
-      getTablesInZone(sheetId, zone) {
-          return this.getTables(sheetId).filter((table) => isZoneInside(table.range.zone, zone));
+      getCoreTable({ sheetId, col, row }) {
+          return this.getCoreTables(sheetId).find((table) => isInside(col, row, table.range.zone));
       }
       getTablesOverlappingZones(sheetId, zones) {
-          return this.getTables(sheetId).filter((table) => zones.some((zone) => overlap(table.range.zone, zone)));
-      }
-      getFilterHeaders(sheetId) {
-          const headers = [];
-          for (const table of this.getTables(sheetId)) {
-              if (!table.config.hasFilters) {
-                  continue;
-              }
-              const zone = table.range.zone;
-              const row = zone.top;
-              for (let col = zone.left; col <= zone.right; col++) {
-                  headers.push({ col, row });
-              }
-          }
-          return headers;
-      }
-      isFilterHeader({ sheetId, col, row }) {
-          const headers = this.getFilterHeaders(sheetId);
-          return headers.some((header) => header.col === col && header.row === row);
+          return this.getCoreTables(sheetId).filter((table) => zones.some((zone) => overlap(table.range.zone, zone)));
       }
       /** Extend a table down one row */
       extendTableDown(sheetId, table) {
           const newRange = this.getters.extendRange(table.range, "ROW", 1);
-          this.history.update("tables", sheetId, table.id, this.updateTable(table, newRange));
+          this.history.update("tables", sheetId, table.id, this.updateStaticTable(table, newRange));
       }
       /** Extend a table right one col */
       extendTableRight(sheetId, table) {
           const newRange = this.getters.extendRange(table.range, "COL", 1);
-          this.history.update("tables", sheetId, table.id, this.updateTable(table, newRange));
+          this.history.update("tables", sheetId, table.id, this.updateStaticTable(table, newRange));
       }
       /**
        * Check if an UpdateCell command should cause the given table to be extended by one row or col.
@@ -45046,12 +45097,22 @@ stores.inject(MyMetaStore, storeInstance);
               const cellContent = this.getters.getCell(cellPosition)?.content;
               if (cellContent ||
                   this.getters.isInMerge(cellPosition) ||
-                  this.getters.getTable(cellPosition)) {
+                  this.getTablesOverlappingZones(sheetId, [positionToZone(position)]).length) {
                   return "none";
               }
           }
           return direction;
       }
+      getTableFromZone(sheetId, zone) {
+          for (const table of this.getCoreTables(sheetId)) {
+              const tableZone = table.range.zone;
+              // Only check top left to match dynamic tables
+              if (tableZone.left === zone.left && tableZone.top === zone.top) {
+                  return table;
+              }
+          }
+          return undefined;
+      }
       checkUpdatedTableZoneIsValid(cmd) {
           if (!cmd.newTableRange) {
               return "Success" /* CommandResult.Success */;
@@ -45061,7 +45122,11 @@ stores.inject(MyMetaStore, storeInstance);
           if (zoneIsInSheet !== "Success" /* CommandResult.Success */) {
               return zoneIsInSheet;
           }
-          const overlappingTables = this.getTablesOverlappingZones(cmd.sheetId, [newTableZone]).filter((table) => !deepEquals(table.range.zone, cmd.zone));
+          const updatedTable = this.getTableFromZone(cmd.sheetId, cmd.zone);
+          if (!updatedTable) {
+              return "TableNotFound" /* CommandResult.TableNotFound */;
+          }
+          const overlappingTables = this.getTablesOverlappingZones(cmd.sheetId, [newTableZone]).filter((table) => table.id !== updatedTable.id);
           return overlappingTables.length ? "TableOverlap" /* CommandResult.TableOverlap */ : "Success" /* CommandResult.Success */;
       }
       checkTableConfigUpdateIsValid(config) {
@@ -45079,7 +45144,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return "Success" /* CommandResult.Success */;
       }
-      createTable(id, tableRange, config, filters) {
+      createStaticTable(id, type, tableRange, config, filters) {
           const zone = tableRange.zone;
           if (!filters) {
               filters = [];
@@ -45094,9 +45159,51 @@ stores.inject(MyMetaStore, storeInstance);
               range: tableRange,
               filters,
               config,
+              type,
+          };
+      }
+      createDynamicTable(id, tableRange, config) {
+          const zone = zoneToTopLeft(tableRange.zone);
+          return {
+              id,
+              range: this.getters.getRangeFromZone(tableRange.sheetId, zone),
+              config,
+              type: "dynamic",
           };
       }
-      updateTable(table, newRange, configUpdate) {
+      updateTable(cmd) {
+          const table = this.getTableFromZone(cmd.sheetId, cmd.zone);
+          if (!table) {
+              return;
+          }
+          const newTableRange = cmd.newTableRange
+              ? this.getters.getRangeFromRangeData(cmd.newTableRange)
+              : undefined;
+          if (newTableRange) {
+              const mergesInTarget = this.getters.getMergesInZone(cmd.sheetId, newTableRange.zone);
+              this.dispatch("REMOVE_MERGE", { sheetId: cmd.sheetId, target: mergesInTarget });
+          }
+          const range = newTableRange || table.range;
+          const newConfig = this.updateTableConfig(cmd.config, table.config);
+          const newTableType = cmd.tableType ?? table.type;
+          if ((newTableType === "dynamic" && table.type !== "dynamic") ||
+              (newTableType !== "dynamic" && table.type === "dynamic")) {
+              const newTable = newTableType === "dynamic"
+                  ? this.createDynamicTable(table.id, range, newConfig)
+                  : this.createStaticTable(table.id, newTableType, range, newConfig);
+              this.history.update("tables", cmd.sheetId, table.id, newTable);
+          }
+          else {
+              const updatedTable = table.type === "dynamic"
+                  ? this.updateDynamicTable(table, range, newConfig)
+                  : this.updateStaticTable(table, range, newConfig, newTableType);
+              this.history.update("tables", cmd.sheetId, table.id, updatedTable);
+          }
+      }
+      updateStaticTable(table, newRange, configUpdate, newTableType = table.type) {
+          if (newTableType === "dynamic") {
+              throw new Error("Cannot use updateStaticTable to update a dynamic table");
+          }
           const tableRange = newRange ? newRange : table.range;
           const tableZone = tableRange.zone;
           const newConfig = this.updateTableConfig(configUpdate, table.config);
@@ -45117,8 +45224,16 @@ stores.inject(MyMetaStore, storeInstance);
               range: tableRange,
               config,
               filters: filters.length ? filters : table.filters,
+              type: newTableType,
           };
       }
+      updateDynamicTable(table, newRange, newConfig) {
+          const range = newRange
+              ? this.getters.getRangeFromZone(newRange.sheetId, zoneToTopLeft(newRange.zone))
+              : table.range;
+          const config = newConfig ? newConfig : table.config;
+          return { ...table, range, config };
+      }
       /**
        * Update the old config of a table with the new partial config from an UpdateTable command.
        *
@@ -45140,35 +45255,29 @@ stores.inject(MyMetaStore, storeInstance);
       }
       createFilterFromZone(id, sheetId, zone, config) {
           const range = this.getters.getRangeFromZone(sheetId, zone);
-          return this.createFilter(id, range, config);
-      }
-      createFilter(id, range, config) {
-          const zone = range.zone;
-          if (zone.left !== zone.right) {
-              throw new Error("Can only define a filter on a single column");
-          }
-          const contentZone = getTableContentZone(zone, config);
-          const filteredRange = contentZone
-              ? this.getters.getRangeFromZone(range.sheetId, contentZone)
-              : undefined;
-          return {
-              id,
-              rangeWithHeaders: range,
-              col: zone.left,
-              filteredRange,
-          };
+          return createFilter(id, range, config, this.getters.getRangeFromZone);
       }
-      copyTableForSheet(sheetId, table) {
+      copyStaticTableForSheet(sheetId, table) {
           const newRange = this.getters.getRangeFromZone(sheetId, table.range.zone);
           const newFilters = table.filters.map((filter) => {
               const newFilterRange = this.getters.getRangeFromZone(sheetId, filter.rangeWithHeaders.zone);
-              return this.createFilter(filter.id, newFilterRange, table.config);
+              return createFilter(filter.id, newFilterRange, table.config, this.getters.getRangeFromZone);
           });
           return {
               id: table.id,
               range: newRange,
               filters: newFilters,
               config: deepCopy(table.config),
+              type: table.type,
+          };
+      }
+      copyDynamicTableForSheet(sheetId, table) {
+          const newRange = this.getters.getRangeFromZone(sheetId, table.range.zone);
+          return {
+              id: table.id,
+              range: newRange,
+              config: deepCopy(table.config),
+              type: "dynamic",
           };
       }
       applyRangeChangeOnTable(sheetId, table, applyChange) {
@@ -45183,6 +45292,11 @@ stores.inject(MyMetaStore, storeInstance);
               default:
                   newTableRange = tableRangeChange.range;
           }
+          if (table.type === "dynamic") {
+              const newTable = this.updateDynamicTable(table, newTableRange);
+              this.history.update("tables", sheetId, table.id, newTable);
+              return;
+          }
           const filters = [];
           for (const filter of table.filters) {
               const filterRangeChange = applyChange(filter.rangeWithHeaders);
@@ -45194,7 +45308,7 @@ stores.inject(MyMetaStore, storeInstance);
                       break;
                   default:
                       const newFilterRange = filterRangeChange.range;
-                      const newFilter = this.createFilter(filter.id, newFilterRange, table.config);
+                      const newFilter = createFilter(filter.id, newFilterRange, table.config, this.getters.getRangeFromZone);
                       filters.push(newFilter);
               }
           }
@@ -45209,7 +45323,7 @@ stores.inject(MyMetaStore, storeInstance);
               }
               filters.sort((f1, f2) => f1.col - f2.col);
           }
-          const newTable = this.createTable(table.id, newTableRange, table.config, filters);
+          const newTable = this.createStaticTable(table.id, table.type, newTableRange, table.config, filters);
           this.history.update("tables", sheetId, table.id, newTable);
       }
       // ---------------------------------------------------------------------------
@@ -45220,16 +45334,20 @@ stores.inject(MyMetaStore, storeInstance);
               for (const tableData of sheet.tables || []) {
                   const uuid = this.uuidGenerator.uuidv4();
                   const tableConfig = tableData.config || DEFAULT_TABLE_CONFIG;
-                  const tableRange = this.getters.getRangeFromSheetXC(sheet.id, tableData.range);
-                  const table = this.createTable(uuid, tableRange, tableConfig);
+                  const range = this.getters.getRangeFromSheetXC(sheet.id, tableData.range);
+                  const tableType = tableData.type || "static";
+                  const table = tableType === "dynamic"
+                      ? this.createDynamicTable(uuid, range, tableConfig)
+                      : this.createStaticTable(uuid, tableType, range, tableConfig);
                   this.history.update("tables", sheet.id, table.id, table);
               }
           }
       }
       export(data) {
           for (const sheet of data.sheets) {
-              for (const table of this.getTables(sheet.id)) {
-                  const tableData = { range: zoneToXc(table.range.zone) };
+              for (const table of this.getCoreTables(sheet.id)) {
+                  const range = zoneToXc(table.range.zone);
+                  const tableData = { range, type: table.type };
                   if (!deepEquals(table.config, DEFAULT_TABLE_CONFIG)) {
                       tableData.config = table.config;
                   }
@@ -46945,14 +47063,18 @@ stores.inject(MyMetaStore, storeInstance);
           if (!this.spreadingRelations.isArrayFormula(position)) {
               return [];
           }
-          return Array.from(this.spreadingRelations.getArrayResultPositions(position));
+          if (this.evaluatedCells.get(position)?.type === CellValueType.error) {
+              return [position];
+          }
+          const spreadPositions = Array.from(this.spreadingRelations.getArrayResultPositions(position));
+          return [position, ...spreadPositions];
       }
       getEvaluatedPositions() {
           return this.evaluatedCells.keys();
       }
       getArrayFormulaSpreadingOn(position) {
           if (!this.spreadingRelations.hasArrayFormulaResult(position)) {
-              return undefined;
+              return this.spreadingRelations.isArrayFormula(position) ? position : undefined;
           }
           const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(position);
           return Array.from(arrayFormulas).find((position) => !this.blockedArrayFormulas.has(position));
@@ -47081,6 +47203,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (!this.blockedArrayFormulas.has(position)) {
               this.invalidateSpreading(position);
           }
+          this.spreadingRelations.removeNode(position);
           const cell = this.getters.getCell(position);
           if (cell === undefined) {
               return EMPTY_CELL;
@@ -47191,7 +47314,6 @@ stores.inject(MyMetaStore, storeInstance);
               this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([child]));
               this.nextPositionsToUpdate.addMany(this.getArrayFormulasBlockedByOrSpreadingOn(child));
           }
-          this.spreadingRelations.removeNode(position);
       }
       // ----------------------------------------------------------
       //                 COMMON FUNCTIONALITY
@@ -48289,6 +48411,181 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class DynamicTablesPlugin extends UIPlugin {
+      static getters = [
+          "canCreateDynamicTableOnZones",
+          "doesZonesContainFilter",
+          "getFilter",
+          "getFilters",
+          "getTable",
+          "getTables",
+          "getTablesOverlappingZones",
+          "getFilterId",
+          "getFilterHeaders",
+          "isFilterHeader",
+      ];
+      tables = {};
+      handle(cmd) {
+          if (invalidateEvaluationCommands.has(cmd.type) ||
+              (cmd.type === "UPDATE_CELL" && "content" in cmd) ||
+              cmd.type === "EVALUATE_CELLS") {
+              this.tables = {};
+              return;
+          }
+          switch (cmd.type) {
+              case "CREATE_TABLE":
+              case "REMOVE_TABLE":
+              case "UPDATE_TABLE":
+              case "DELETE_CONTENT":
+                  this.tables = {};
+                  break;
+          }
+      }
+      finalize() {
+          for (const sheetId of this.getters.getSheetIds()) {
+              if (!this.tables[sheetId]) {
+                  this.tables[sheetId] = this.computeTables(sheetId);
+              }
+          }
+      }
+      computeTables(sheetId) {
+          const tables = [];
+          const coreTables = this.getters.getCoreTables(sheetId);
+          // First we create the static tables, so we can use them to compute collision with dynamic tables
+          for (const table of coreTables) {
+              if (table.type === "dynamic")
+                  continue;
+              tables.push(table);
+          }
+          const staticTables = [...tables];
+          // Then we create the dynamic tables
+          for (const coreTable of coreTables) {
+              if (coreTable.type !== "dynamic")
+                  continue;
+              const table = this.coreTableToTable(sheetId, coreTable);
+              let tableZone = table.range.zone;
+              // Reduce the zone to avoid collision with static tables. Per design, dynamic tables can't overlap with other
+              // dynamic tables, because formulas cannot spread on the same area, so we don't need to check for that.
+              for (const staticTable of staticTables) {
+                  if (overlap(tableZone, staticTable.range.zone)) {
+                      tableZone = { ...tableZone, right: staticTable.range.zone.left - 1 };
+                  }
+              }
+              tables.push({ ...table, range: this.getters.getRangeFromZone(sheetId, tableZone) });
+          }
+          return tables;
+      }
+      getFilters(sheetId) {
+          return this.getTables(sheetId)
+              .filter((table) => table.config.hasFilters)
+              .map((table) => table.filters)
+              .flat();
+      }
+      getTables(sheetId) {
+          return this.tables[sheetId] || [];
+      }
+      getFilter(position) {
+          const table = this.getTable(position);
+          if (!table || !table.config.hasFilters) {
+              return undefined;
+          }
+          return table.filters.find((filter) => filter.col === position.col);
+      }
+      getFilterId(position) {
+          return this.getFilter(position)?.id;
+      }
+      getTable({ sheetId, col, row }) {
+          return this.getTables(sheetId).find((table) => isInside(col, row, table.range.zone));
+      }
+      getTablesOverlappingZones(sheetId, zones) {
+          return this.getTables(sheetId).filter((table) => zones.some((zone) => overlap(table.range.zone, zone)));
+      }
+      doesZonesContainFilter(sheetId, zones) {
+          return this.getTablesOverlappingZones(sheetId, zones).some((table) => table.config.hasFilters);
+      }
+      getFilterHeaders(sheetId) {
+          const headers = [];
+          for (const table of this.getTables(sheetId)) {
+              if (!table.config.hasFilters) {
+                  continue;
+              }
+              const zone = table.range.zone;
+              const row = zone.top;
+              for (let col = zone.left; col <= zone.right; col++) {
+                  headers.push({ sheetId, col, row });
+              }
+          }
+          return headers;
+      }
+      isFilterHeader({ sheetId, col, row }) {
+          const headers = this.getFilterHeaders(sheetId);
+          return headers.some((header) => header.col === col && header.row === row);
+      }
+      /**
+       * Check if we can create a dynamic table on the given zones.
+       * - The zones must be continuous
+       * - The union of the zones must be either:
+       *    - A single cell that contains an array formula
+       *    - All the spread cells of a single array formula
+       */
+      canCreateDynamicTableOnZones(sheetId, zones) {
+          if (!areZonesContinuous(zones)) {
+              return false;
+          }
+          const unionZone = union(...zones);
+          const topLeft = { col: unionZone.left, row: unionZone.top, sheetId };
+          const parentSpreadingCell = this.getters.getArrayFormulaSpreadingOn(topLeft);
+          if (!parentSpreadingCell) {
+              return false;
+          }
+          else if (deepEquals(parentSpreadingCell, topLeft) && getZoneArea(unionZone) === 1) {
+              return true;
+          }
+          const spreadPositions = this.getters.getSpreadPositionsOf(parentSpreadingCell);
+          return deepEquals(unionZone, unionPositionsToZone(spreadPositions));
+      }
+      coreTableToTable(sheetId, table) {
+          if (table.type !== "dynamic") {
+              return table;
+          }
+          const tableZone = table.range.zone;
+          const tablePosition = { sheetId, col: tableZone.left, row: tableZone.top };
+          const spreadPositions = this.getters.getSpreadPositionsOf(tablePosition);
+          const zone = spreadPositions.length ? unionPositionsToZone(spreadPositions) : table.range.zone;
+          const range = this.getters.getRangeFromZone(sheetId, zone);
+          const filters = this.getDynamicTableFilters(sheetId, table, zone);
+          return { id: table.id, range, filters, config: table.config };
+      }
+      getDynamicTableFilters(sheetId, table, tableZone) {
+          const filters = [];
+          const { top, bottom, left, right } = tableZone;
+          for (let col = left; col <= right; col++) {
+              const tableColIndex = col - left;
+              const zone = { left: col, right: col, top, bottom };
+              const filter = createFilter(this.getDynamicTableFilterId(table.id, tableColIndex), this.getters.getRangeFromZone(sheetId, zone), table.config, this.getters.getRangeFromZone);
+              filters.push(filter);
+          }
+          return filters;
+      }
+      getDynamicTableFilterId(tableId, tableCol) {
+          return tableId + "_" + tableCol;
+      }
+      exportForExcel(data) {
+          for (const sheet of data.sheets) {
+              for (const tableData of sheet.tables) {
+                  const zone = toZone(tableData.range);
+                  const topLeft = { sheetId: sheet.id, col: zone.left, row: zone.top };
+                  const coreTable = this.getters.getCoreTable(topLeft);
+                  const table = this.getTable(topLeft);
+                  if (coreTable?.type !== "dynamic" || !table) {
+                      continue;
+                  }
+                  tableData.range = zoneToXc(table.range.zone);
+              }
+          }
+      }
+  }
+
   class HeaderSizeUIPlugin extends UIPlugin {
       static getters = ["getRowSize", "getHeaderSize"];
       tallestCellInRow = {};
@@ -51336,10 +51633,11 @@ stores.inject(MyMetaStore, storeInstance);
       handle(cmd) {
           switch (cmd.type) {
               case "AUTOFILL_TABLE_COLUMN":
-                  const table = this.getters.getTable(cmd);
+                  const table = this.getters.getCoreTable(cmd);
                   const cell = this.getters.getCell(cmd);
-                  if (!table || !table.config.automaticAutofill || !cell?.isFormula)
+                  if (!table?.config.automaticAutofill || table.type === "dynamic" || !cell?.isFormula) {
                       return;
+                  }
                   const { col, row } = cmd;
                   const tableContentZone = getTableContentZone(table.range.zone, table.config);
                   if (tableContentZone && isInside(col, row, tableContentZone)) {
@@ -52068,9 +52366,6 @@ stores.inject(MyMetaStore, storeInstance);
               case "START":
                   for (const sheetId of this.getters.getSheetIds()) {
                       this.filterValues[sheetId] = {};
-                      for (const filter of this.getters.getFilters(sheetId)) {
-                          this.filterValues[sheetId][filter.id] = [];
-                      }
                   }
                   break;
               case "CREATE_SHEET":
@@ -52091,16 +52386,7 @@ stores.inject(MyMetaStore, storeInstance);
                   this.updateHiddenRows();
                   break;
               case "DUPLICATE_SHEET":
-                  const filterValues = {};
-                  for (const newFilter of this.getters.getFilters(cmd.sheetIdTo)) {
-                      const zone = newFilter.rangeWithHeaders.zone;
-                      filterValues[newFilter.id] = this.getFilterHiddenValues({
-                          sheetId: cmd.sheetId,
-                          col: zone.left,
-                          row: zone.top,
-                      });
-                  }
-                  this.filterValues[cmd.sheetIdTo] = filterValues;
+                  this.filterValues[cmd.sheetIdTo] = deepCopy(this.filterValues[cmd.sheetId]);
                   break;
               // If we don't handle DELETE_SHEET, on one hand we will have some residual data, on the other hand we keep the data
               // on DELETE_SHEET followed by undo
@@ -54044,8 +54330,9 @@ stores.inject(MyMetaStore, storeInstance);
       .add("evaluation_chart", EvaluationChartPlugin)
       .add("evaluation_cf", EvaluationConditionalFormatPlugin)
       .add("row_size", HeaderSizeUIPlugin)
-      .add("custom_colors", CustomColorsPlugin)
-      .add("data_validation_ui", EvaluationDataValidationPlugin);
+      .add("data_validation_ui", EvaluationDataValidationPlugin)
+      .add("dynamic_tables", DynamicTablesPlugin)
+      .add("custom_colors", CustomColorsPlugin);
 
   const clickableCellRegistry = new Registry();
   clickableCellRegistry.add("link", {
@@ -60176,9 +60463,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "17.2.1";
-  __info__.date = "2024-03-25T09:41:58.737Z";
-  __info__.hash = "f97284c";
+  __info__.version = "17.3.0-alpha.1";
+  __info__.date = "2024-03-25T09:43:36.072Z";
+  __info__.hash = "4095c41";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);