@odoo/o-spreadsheet 17.4.28 → 17.4.30

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.28
- * @date 2025-03-26T12:48:33.387Z
- * @hash a81a8f4
+ * @version 17.4.30
+ * @date 2025-04-14T17:17:01.767Z
+ * @hash e4cf37d
  */
 
 (function (exports, owl) {
@@ -773,8 +773,7 @@
    *
    * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes
    */
-  const whiteSpaceSpecialCharacters = [
-      " ",
+  const specialWhiteSpaceSpecialCharacters = [
       "\t",
       "\f",
       "\v",
@@ -789,7 +788,7 @@
       String.fromCharCode(parseInt("3000", 16)),
       String.fromCharCode(parseInt("feff", 16)),
   ];
-  const whiteSpaceRegexp = new RegExp(whiteSpaceSpecialCharacters.join("|"), "g");
+  const specialWhiteSpaceRegexp = new RegExp(specialWhiteSpaceSpecialCharacters.join("|"), "g");
   const newLineRegexp = /(\r\n|\r)/g;
   /**
    * Replace all different newlines characters by \n
@@ -2169,6 +2168,7 @@
       "CLEAR_FORMATTING",
       "SET_BORDER",
       "SET_ZONE_BORDERS",
+      "SET_BORDERS_ON_TARGET",
       /** CHART */
       "CREATE_CHART",
       "UPDATE_CHART",
@@ -5652,6 +5652,7 @@
   }
 
   class BorderClipboardHandler extends AbstractCellClipboardHandler {
+      queuedBordersToAdd = {};
       copy(data) {
           const sheetId = data.sheetId;
           if (data.zones.length === 0) {
@@ -5682,6 +5683,7 @@
               const { left, top } = zones[0];
               this.pasteZone(sheetId, left, top, content.borders);
           }
+          this.executeQueuedChanges(sheetId);
       }
       pasteZone(sheetId, col, row, borders) {
           for (const [r, rowBorders] of borders.entries()) {
@@ -5700,7 +5702,20 @@
               ...targetBorders,
               ...originBorders,
           };
-          this.dispatch("SET_BORDER", { ...target, border });
+          const borderKey = JSON.stringify(border);
+          if (!this.queuedBordersToAdd[borderKey]) {
+              this.queuedBordersToAdd[borderKey] = [];
+          }
+          this.queuedBordersToAdd[borderKey].push(positionToZone(target));
+      }
+      executeQueuedChanges(pasteSheetTarget) {
+          for (const borderKey in this.queuedBordersToAdd) {
+              const zones = this.queuedBordersToAdd[borderKey];
+              const border = JSON.parse(borderKey);
+              const target = recomputeZones(zones, []);
+              this.dispatch("SET_BORDERS_ON_TARGET", { sheetId: pasteSheetTarget, target, border });
+          }
+          this.queuedBordersToAdd = {};
       }
   }
 
@@ -5726,8 +5741,12 @@
       str = replaceNewLines(str);
       const chars = new TokenizingChars(str);
       const result = [];
+      const tokenizeSpace = specialWhiteSpaceRegexp.test(str)
+          ? tokenizeSpecialCharacterSpace
+          : tokenizeSimpleSpace;
       while (!chars.isOver()) {
-          let token = tokenizeSpace(chars) ||
+          let token = tokenizeNewLine(chars) ||
+              tokenizeSpace(chars) ||
               tokenizeArgsSeparator(chars, locale) ||
               tokenizeParenthesis(chars) ||
               tokenizeOperator(chars) ||
@@ -5861,17 +5880,19 @@
       }
       return null;
   }
-  function tokenizeSpace(chars) {
-      let length = 0;
-      while (chars.current === NEWLINE) {
-          length++;
-          chars.shift();
+  function tokenizeSpecialCharacterSpace(chars) {
+      let spaces = "";
+      while (chars.current === " " || (chars.current && chars.current.match(specialWhiteSpaceRegexp))) {
+          spaces += chars.shift();
       }
-      if (length) {
-          return { type: "SPACE", value: NEWLINE.repeat(length) };
+      if (spaces) {
+          return { type: "SPACE", value: spaces };
       }
+      return null;
+  }
+  function tokenizeSimpleSpace(chars) {
       let spaces = "";
-      while (chars.current && chars.current.match(whiteSpaceRegexp)) {
+      while (chars.current === " ") {
           spaces += chars.shift();
       }
       if (spaces) {
@@ -5879,6 +5900,17 @@
       }
       return null;
   }
+  function tokenizeNewLine(chars) {
+      let length = 0;
+      while (chars.current === NEWLINE) {
+          length++;
+          chars.shift();
+      }
+      if (length) {
+          return { type: "SPACE", value: NEWLINE.repeat(length) };
+      }
+      return null;
+  }
   function tokenizeInvalidRange(chars) {
       if (chars.currentStartsWith(CellErrorType.InvalidReference)) {
           chars.advanceBy(CellErrorType.InvalidReference.length);
@@ -6947,6 +6979,7 @@
 
   class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
       uuidGenerator = new UuidGenerator();
+      queuedChanges = {};
       copy(data) {
           if (!data.zones.length) {
               return;
@@ -6968,6 +7001,7 @@
           return { cfRules };
       }
       paste(target, clippedContent, options) {
+          this.queuedChanges = {};
           if (options.pasteOption === "asValue") {
               return;
           }
@@ -6979,6 +7013,7 @@
           else {
               this.pasteFromCut(sheetId, zones, clippedContent);
           }
+          this.executeQueuedChanges();
       }
       pasteFromCut(sheetId, target, content) {
           const selection = target[0];
@@ -6996,12 +7031,13 @@
       }
       pasteCf(origin, target, isCutOperation) {
           if (origin?.rules && origin.rules.length > 0) {
+              const originZone = positionToZone(origin.position);
               const zone = positionToZone(target);
               for (const rule of origin.rules) {
                   const toRemoveZones = [];
                   if (isCutOperation) {
                       //remove from current rule
-                      toRemoveZones.push(positionToZone(origin.position));
+                      toRemoveZones.push(originZone);
                   }
                   if (origin.position.sheetId === target.sheetId) {
                       this.adaptCFRules(origin.position.sheetId, rule, [zone], toRemoveZones);
@@ -7018,36 +7054,56 @@
        * Add or remove cells to a given conditional formatting rule.
        */
       adaptCFRules(sheetId, cf, toAdd, toRemove) {
-          const newRangesXc = this.getters.getAdaptedCfRanges(sheetId, cf, toAdd, toRemove);
-          if (!newRangesXc) {
-              return;
+          if (!this.queuedChanges[sheetId]) {
+              this.queuedChanges[sheetId] = [];
           }
-          if (newRangesXc.length === 0) {
-              this.dispatch("REMOVE_CONDITIONAL_FORMAT", { id: cf.id, sheetId });
-              return;
+          const queuedChange = this.queuedChanges[sheetId].find((queued) => queued.cf.id === cf.id);
+          if (!queuedChange) {
+              this.queuedChanges[sheetId].push({ toAdd, toRemove, cf });
+          }
+          else {
+              queuedChange.toAdd.push(...toAdd);
+              queuedChange.toRemove.push(...toRemove);
+          }
+      }
+      executeQueuedChanges() {
+          for (const sheetId in this.queuedChanges) {
+              for (const { toAdd, toRemove, cf } of this.queuedChanges[sheetId]) {
+                  const newRangesXc = this.getters.getAdaptedCfRanges(sheetId, cf, toAdd, toRemove);
+                  if (!newRangesXc) {
+                      continue;
+                  }
+                  if (newRangesXc.length === 0) {
+                      this.dispatch("REMOVE_CONDITIONAL_FORMAT", { id: cf.id, sheetId });
+                      continue;
+                  }
+                  this.dispatch("ADD_CONDITIONAL_FORMAT", {
+                      cf: {
+                          id: cf.id,
+                          rule: cf.rule,
+                          stopIfTrue: cf.stopIfTrue,
+                      },
+                      ranges: newRangesXc,
+                      sheetId,
+                  });
+              }
           }
-          this.dispatch("ADD_CONDITIONAL_FORMAT", {
-              cf: {
-                  id: cf.id,
-                  rule: cf.rule,
-                  stopIfTrue: cf.stopIfTrue,
-              },
-              ranges: newRangesXc,
-              sheetId,
-          });
       }
       getCFToCopyTo(targetSheetId, originCF) {
-          const cfInTarget = this.getters
+          let targetCF = this.getters
               .getConditionalFormats(targetSheetId)
               .find((cf) => cf.stopIfTrue === originCF.stopIfTrue && deepEquals(cf.rule, originCF.rule));
-          return cfInTarget
-              ? cfInTarget
-              : { ...originCF, id: this.uuidGenerator.smallUuid(), ranges: [] };
+          const queuedCfs = this.queuedChanges[targetSheetId];
+          if (!targetCF && queuedCfs) {
+              targetCF = queuedCfs.find((queued) => queued.cf.stopIfTrue === originCF.stopIfTrue && deepEquals(queued.cf.rule, originCF.rule))?.cf;
+          }
+          return targetCF || { ...originCF, id: this.uuidGenerator.uuidv4(), ranges: [] };
       }
   }
 
   class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
       uuidGenerator = new UuidGenerator();
+      queuedChanges = {};
       copy(data) {
           const { rowsIndexes, columnsIndexes } = data;
           const sheetId = data.sheetId;
@@ -7064,6 +7120,7 @@
           return { dvRules };
       }
       paste(target, clippedContent, options) {
+          this.queuedChanges = {};
           if (options.pasteOption) {
               return;
           }
@@ -7075,6 +7132,7 @@
           else {
               this.pasteFromCut(sheetId, zones, clippedContent);
           }
+          this.executeQueuedChanges();
       }
       pasteFromCut(sheetId, target, content) {
           const selection = target[0];
@@ -7093,6 +7151,7 @@
       pasteDataValidation(origin, target, isCutOperation) {
           if (origin) {
               const zone = positionToZone(target);
+              const originZone = positionToZone(origin.position);
               const rule = origin.rule;
               if (!rule) {
                   const targetRule = this.getters.getValidationRuleForCell(target);
@@ -7104,7 +7163,7 @@
               }
               const toRemoveZone = [];
               if (isCutOperation) {
-                  toRemoveZone.push(positionToZone(origin.position));
+                  toRemoveZone.push(originZone);
               }
               if (origin.position.sheetId === target.sheetId) {
                   const copyToRule = this.getDataValidationRuleToCopyTo(target.sheetId, rule, false);
@@ -7121,29 +7180,55 @@
           }
       }
       getDataValidationRuleToCopyTo(targetSheetId, originRule, newId = true) {
-          const ruleInTargetSheet = this.getters
+          let targetRule = this.getters
               .getDataValidationRules(targetSheetId)
               .find((rule) => deepEquals(originRule.criterion, rule.criterion) &&
               originRule.isBlocking === rule.isBlocking);
-          return ruleInTargetSheet
-              ? ruleInTargetSheet
-              : { ...originRule, id: newId ? this.uuidGenerator.smallUuid() : originRule.id, ranges: [] };
+          const queuedRules = this.queuedChanges[targetSheetId];
+          if (!targetRule && queuedRules) {
+              targetRule = queuedRules.find((queued) => deepEquals(originRule.criterion, queued.rule.criterion) &&
+                  originRule.isBlocking === queued.rule.isBlocking)?.rule;
+          }
+          return (targetRule || {
+              ...originRule,
+              id: newId ? this.uuidGenerator.uuidv4() : originRule.id,
+              ranges: [],
+          });
       }
       /**
        * Add or remove XCs to a given data validation rule.
        */
       adaptDataValidationRule(sheetId, rule, toAdd, toRemove) {
-          const dvZones = rule.ranges.map((range) => range.zone);
-          const newDvZones = recomputeZones([...dvZones, ...toAdd], toRemove);
-          if (newDvZones.length === 0) {
-              this.dispatch("REMOVE_DATA_VALIDATION_RULE", { sheetId, id: rule.id });
-              return;
+          if (!this.queuedChanges[sheetId]) {
+              this.queuedChanges[sheetId] = [];
+          }
+          const queuedChange = this.queuedChanges[sheetId].find((queued) => queued.rule.id === rule.id);
+          if (!queuedChange) {
+              this.queuedChanges[sheetId].push({ toAdd, toRemove, rule });
+          }
+          else {
+              queuedChange.toAdd.push(...toAdd);
+              queuedChange.toRemove.push(...toRemove);
+          }
+      }
+      executeQueuedChanges() {
+          for (const sheetId in this.queuedChanges) {
+              for (const { toAdd, toRemove, rule: dv } of this.queuedChanges[sheetId]) {
+                  // Remove the zones first in case the same position is in toAdd and toRemove
+                  const dvZones = dv.ranges.map((range) => range.zone);
+                  const withRemovedZones = recomputeZones(dvZones, toRemove);
+                  const newDvZones = recomputeZones([...withRemovedZones, ...toAdd], []);
+                  if (newDvZones.length === 0) {
+                      this.dispatch("REMOVE_DATA_VALIDATION_RULE", { sheetId, id: dv.id });
+                      continue;
+                  }
+                  this.dispatch("ADD_DATA_VALIDATION_RULE", {
+                      rule: { id: dv.id, criterion: dv.criterion, isBlocking: dv.isBlocking },
+                      ranges: newDvZones.map((zone) => this.getters.getRangeDataFromZone(sheetId, zone)),
+                      sheetId,
+                  });
+              }
           }
-          this.dispatch("ADD_DATA_VALIDATION_RULE", {
-              rule,
-              ranges: newDvZones.map((zone) => this.getters.getRangeDataFromZone(sheetId, zone)),
-              sheetId,
-          });
       }
   }
 
@@ -47546,6 +47631,15 @@ stores.inject(MyMetaStore, storeInstance);
               case "SET_BORDER":
                   this.setBorder(cmd.sheetId, cmd.col, cmd.row, cmd.border);
                   break;
+              case "SET_BORDERS_ON_TARGET":
+                  for (const zone of cmd.target) {
+                      for (let row = zone.top; row <= zone.bottom; row++) {
+                          for (let col = zone.left; col <= zone.right; col++) {
+                              this.setBorder(cmd.sheetId, col, row, cmd.border);
+                          }
+                      }
+                  }
+                  break;
               case "SET_ZONE_BORDERS":
                   if (cmd.border) {
                       const target = cmd.target.map((zone) => this.getters.expandZone(cmd.sheetId, zone));
@@ -49024,8 +49118,9 @@ stores.inject(MyMetaStore, storeInstance);
           if (replaceIndex > -1) {
               currentRanges = rules[replaceIndex].ranges.map(toUnboundedZone);
           }
-          currentRanges = currentRanges.concat(toAdd);
-          return recomputeZones(currentRanges, toRemove).map((zone) => this.getters.getRangeDataFromZone(sheetId, zone));
+          // Remove the zones first in case the same position is in toAdd and toRemove
+          const withRemovedZones = recomputeZones(currentRanges, toRemove);
+          return recomputeZones([...toAdd, ...withRemovedZones], []).map((zone) => this.getters.getRangeDataFromZone(sheetId, zone));
       }
       // ---------------------------------------------------------------------------
       // Private
@@ -56536,25 +56631,6 @@ stores.inject(MyMetaStore, storeInstance);
               case "AUTOFILL_AUTO":
                   this.autofillAuto();
                   break;
-              case "AUTOFILL_CELL":
-                  this.autoFillMerge(cmd.originCol, cmd.originRow, cmd.col, cmd.row);
-                  const sheetId = this.getters.getActiveSheetId();
-                  this.dispatch("UPDATE_CELL", {
-                      sheetId,
-                      col: cmd.col,
-                      row: cmd.row,
-                      style: cmd.style || null,
-                      content: cmd.content || "",
-                      format: cmd.format || "",
-                  });
-                  this.dispatch("SET_BORDER", {
-                      sheetId,
-                      col: cmd.col,
-                      row: cmd.row,
-                      border: cmd.border,
-                  });
-                  this.autofillCF(cmd.originCol, cmd.originRow, cmd.col, cmd.row);
-                  this.autofillDV(cmd.originCol, cmd.originRow, cmd.col, cmd.row);
           }
       }
       // ---------------------------------------------------------------------------
@@ -56578,6 +56654,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const source = this.getters.getSelectedZone();
           const target = this.autofillZone;
+          const autofillCellsData = [];
           switch (this.direction) {
               case "down" /* DIRECTION.DOWN */:
                   for (let col = source.left; col <= source.right; col++) {
@@ -56587,7 +56664,7 @@ stores.inject(MyMetaStore, storeInstance);
                       }
                       const generator = this.createGenerator(xcs);
                       for (let row = target.top; row <= target.bottom; row++) {
-                          this.computeNewCell(generator, col, row, apply);
+                          autofillCellsData.push(this.computeNewCell(generator, col, row));
                       }
                   }
                   break;
@@ -56599,7 +56676,7 @@ stores.inject(MyMetaStore, storeInstance);
                       }
                       const generator = this.createGenerator(xcs);
                       for (let row = target.bottom; row >= target.top; row--) {
-                          this.computeNewCell(generator, col, row, apply);
+                          autofillCellsData.push(this.computeNewCell(generator, col, row));
                       }
                   }
                   break;
@@ -56611,7 +56688,7 @@ stores.inject(MyMetaStore, storeInstance);
                       }
                       const generator = this.createGenerator(xcs);
                       for (let col = target.right; col >= target.left; col--) {
-                          this.computeNewCell(generator, col, row, apply);
+                          autofillCellsData.push(this.computeNewCell(generator, col, row));
                       }
                   }
                   break;
@@ -56623,12 +56700,26 @@ stores.inject(MyMetaStore, storeInstance);
                       }
                       const generator = this.createGenerator(xcs);
                       for (let col = target.left; col <= target.right; col++) {
-                          this.computeNewCell(generator, col, row, apply);
+                          autofillCellsData.push(this.computeNewCell(generator, col, row));
                       }
                   }
                   break;
           }
           if (apply) {
+              const bordersZones = {};
+              const cfNewRanges = {};
+              const dvNewZones = {};
+              const sheetId = this.getters.getActiveSheetId();
+              for (const data of autofillCellsData) {
+                  this.collectBordersData(data, bordersZones);
+                  this.autofillMerge(sheetId, data);
+                  this.autofillCell(sheetId, data);
+                  this.collectConditionalFormatsData(sheetId, data, cfNewRanges);
+                  this.collectDataValidationsData(sheetId, data, dvNewZones);
+              }
+              this.autofillBorders(sheetId, bordersZones);
+              this.autofillConditionalFormats(sheetId, cfNewRanges);
+              this.autofillDataValidations(sheetId, dvNewZones);
               this.autofillZone = undefined;
               this.selection.resizeAnchorZone(this.direction, this.steps);
               this.lastCellSelected = {};
@@ -56637,6 +56728,95 @@ stores.inject(MyMetaStore, storeInstance);
               this.tooltip = undefined;
           }
       }
+      collectBordersData(data, bordersPositions) {
+          const key = JSON.stringify(data.border);
+          if (!(key in bordersPositions)) {
+              bordersPositions[key] = [];
+          }
+          bordersPositions[key].push(positionToZone({ col: data.col, row: data.row }));
+      }
+      collectConditionalFormatsData(sheetId, data, cfNewRanges) {
+          const { originCol, originRow, col, row } = data;
+          const cfsAtOrigin = this.getters.getRulesByCell(sheetId, originCol, originRow);
+          const xc = toXC(col, row);
+          for (const cf of cfsAtOrigin) {
+              if (!(cf.id in cfNewRanges)) {
+                  cfNewRanges[cf.id] = [];
+              }
+              cfNewRanges[cf.id].push(xc);
+          }
+      }
+      collectDataValidationsData(sheetId, data, dvNewZones) {
+          const { originCol, originRow, col, row } = data;
+          const cellPosition = { sheetId, col: originCol, row: originRow };
+          const dvsAtOrigin = this.getters.getValidationRuleForCell(cellPosition);
+          if (!dvsAtOrigin) {
+              return;
+          }
+          if (!(dvsAtOrigin.id in dvNewZones)) {
+              dvNewZones[dvsAtOrigin.id] = [];
+          }
+          dvNewZones[dvsAtOrigin.id].push(positionToZone({ col, row }));
+      }
+      autofillCell(sheetId, data) {
+          this.dispatch("UPDATE_CELL", {
+              sheetId,
+              col: data.col,
+              row: data.row,
+              content: data.content || "",
+              style: data.style || null,
+              format: data.format || "",
+          });
+          // Still usefull in odoo ATM to autofill field sync
+          this.dispatch("AUTOFILL_CELL", data);
+      }
+      autofillBorders(sheetId, bordersPositions) {
+          for (const stringifiedBorder in bordersPositions) {
+              const border = stringifiedBorder === "undefined" ? undefined : JSON.parse(stringifiedBorder);
+              this.dispatch("SET_BORDERS_ON_TARGET", {
+                  sheetId,
+                  border,
+                  target: recomputeZones(bordersPositions[stringifiedBorder]),
+              });
+          }
+      }
+      autofillConditionalFormats(sheetId, cfNewRanges) {
+          for (const cfId in cfNewRanges) {
+              const changes = cfNewRanges[cfId];
+              const cf = this.getters.getConditionalFormats(sheetId).find((cf) => cf.id === cfId);
+              if (!cf) {
+                  continue;
+              }
+              const newCfRanges = this.getters.getAdaptedCfRanges(sheetId, cf, changes.map(toZone), []);
+              if (newCfRanges) {
+                  this.dispatch("ADD_CONDITIONAL_FORMAT", {
+                      cf: {
+                          id: cf.id,
+                          rule: cf.rule,
+                          stopIfTrue: cf.stopIfTrue,
+                      },
+                      ranges: newCfRanges,
+                      sheetId,
+                  });
+              }
+          }
+      }
+      autofillDataValidations(sheetId, dvNewZones) {
+          for (const dvId in dvNewZones) {
+              const changes = dvNewZones[dvId];
+              const dvOrigin = this.getters.getDataValidationRule(sheetId, dvId);
+              if (!dvOrigin) {
+                  continue;
+              }
+              const dvRangesXcs = dvOrigin.ranges.map((range) => range.zone);
+              const newDvRanges = recomputeZones(dvRangesXcs.concat(changes), []);
+              this.dispatch("ADD_DATA_VALIDATION_RULE", {
+                  rule: dvOrigin,
+                  ranges: newDvRanges.map((zone) => this.getters.getRangeDataFromZone(sheetId, zone)),
+                  sheetId,
+              });
+          }
+      }
       /**
        * Select a cell which becomes the last cell of the autofillZone
        */
@@ -56715,22 +56895,20 @@ stores.inject(MyMetaStore, storeInstance);
       /**
        * Generate the next cell
        */
-      computeNewCell(generator, col, row, apply) {
+      computeNewCell(generator, col, row) {
           const { cellData, tooltip, origin } = generator.next();
           const { content, style, border, format } = cellData;
           this.tooltip = tooltip;
-          if (apply) {
-              this.dispatch("AUTOFILL_CELL", {
-                  originCol: origin.col,
-                  originRow: origin.row,
-                  col,
-                  row,
-                  content,
-                  style,
-                  border,
-                  format,
-              });
-          }
+          return {
+              originCol: origin.col,
+              originRow: origin.row,
+              col,
+              row,
+              content,
+              style,
+              border,
+              format,
+          };
       }
       /**
        * Get the rule associated to the current cell
@@ -56798,8 +56976,8 @@ stores.inject(MyMetaStore, storeInstance);
               ? position[first].value
               : position[second].value;
       }
-      autoFillMerge(originCol, originRow, col, row) {
-          const sheetId = this.getters.getActiveSheetId();
+      autofillMerge(sheetId, data) {
+          const { originCol, originRow, col, row } = data;
           const position = { sheetId, col, row };
           const originPosition = { sheetId, col: originCol, row: originRow };
           if (this.getters.isInMerge(position) && !this.getters.isInMerge(originPosition)) {
@@ -56826,35 +57004,6 @@ stores.inject(MyMetaStore, storeInstance);
               });
           }
       }
-      autofillCF(originCol, originRow, col, row) {
-          const sheetId = this.getters.getActiveSheetId();
-          const cfOrigin = this.getters.getRulesByCell(sheetId, originCol, originRow);
-          for (const cf of cfOrigin) {
-              const newCfRanges = this.getters.getAdaptedCfRanges(sheetId, cf, [positionToZone({ col, row })], []);
-              if (newCfRanges) {
-                  this.dispatch("ADD_CONDITIONAL_FORMAT", {
-                      cf: deepCopy(cf),
-                      ranges: newCfRanges,
-                      sheetId,
-                  });
-              }
-          }
-      }
-      autofillDV(originCol, originRow, col, row) {
-          const sheetId = this.getters.getActiveSheetId();
-          const cellPosition = { sheetId, col: originCol, row: originRow };
-          const dvOrigin = this.getters.getValidationRuleForCell(cellPosition);
-          if (!dvOrigin) {
-              return;
-          }
-          const dvRangesZones = dvOrigin.ranges.map((range) => range.zone);
-          const newDvRanges = recomputeZones(dvRangesZones.concat(positionToZone({ col, row })), []);
-          this.dispatch("ADD_DATA_VALIDATION_RULE", {
-              rule: dvOrigin,
-              ranges: newDvRanges.map((zone) => this.getters.getRangeDataFromZone(sheetId, zone)),
-              sheetId,
-          });
-      }
       // ---------------------------------------------------------------------------
       // Grid rendering
       // ---------------------------------------------------------------------------
@@ -69226,9 +69375,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "17.4.28";
-  __info__.date = "2025-03-26T12:48:33.387Z";
-  __info__.hash = "a81a8f4";
+  __info__.version = "17.4.30";
+  __info__.date = "2025-04-14T17:17:01.767Z";
+  __info__.hash = "e4cf37d";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);