@odoo/o-spreadsheet 17.0.56 → 17.0.58

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.0.56
- * @date 2025-04-04T08:36:58.258Z
- * @hash c484787
+ * @version 17.0.58
+ * @date 2025-04-18T16:20:26.099Z
+ * @hash 88d92de
  */
 
 (function (exports, owl) {
@@ -2002,6 +2002,7 @@
       "CLEAR_FORMATTING",
       "SET_BORDER",
       "SET_ZONE_BORDERS",
+      "SET_BORDERS_ON_TARGET",
       /** CHART */
       "CREATE_CHART",
       "UPDATE_CHART",
@@ -4816,7 +4817,7 @@
       if (executed.type === "ADD_COLUMNS_ROWS") {
           return expandZoneOnInsertion(zone, executed.dimension === "COL" ? "left" : "top", executed.base, executed.position, executed.quantity);
       }
-      return { ...zone };
+      return zone;
   }
   function transformRangeData(range, executed) {
       const deletedSheet = executed.type === "DELETE_SHEET" && executed.sheetId;
@@ -7617,6 +7618,12 @@
       }
       return null;
   }
+  /**
+    - \p{L} is for any letter (from any language)
+    - \p{N} is for any number
+    - the u flag at the end is for unicode, which enables the `\p{...}` syntax
+   */
+  const unicodeSymbolCharRegexp = /\p{L}|\p{N}|_|\.|!|\$/u;
   const SYMBOL_CHARS = new Set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.!$");
   /**
    * A "Symbol" is just basically any word-like element that can appear in a
@@ -7657,7 +7664,8 @@
               };
           }
       }
-      while (chars.current && SYMBOL_CHARS.has(chars.current)) {
+      while (chars.current &&
+          (SYMBOL_CHARS.has(chars.current) || chars.current.match(unicodeSymbolCharRegexp))) {
           result += chars.shift();
       }
       if (result.length) {
@@ -34684,6 +34692,15 @@
               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));
@@ -36690,6 +36707,353 @@
       }
   }
 
+  /**
+   * ####################################################
+   * # INTRODUCTION
+   * ####################################################
+   *
+   * This file contain the function recomputeZones.
+   * This function try to recompute in a performant way
+   * an ensemble of zones possibly overlapping to avoid
+   * overlapping and to reduce the number of zones.
+   *
+   * It also allows to remove some zones from the ensemble.
+   *
+   * In the following example, 2 zones are overlapping.
+   * Applying recomputeZones will return zones without
+   * overlapping:
+   *
+   * ["B3:D4", "D2:E3"]         ["B3:C4", "D2:D4", "E2:E3"]
+   *
+   *      A B C D E                    A B C D E
+   *    1       ___                  1       ___
+   *    2   ___|_  |                 2   ___| | |
+   *    3  |   |_|_|      --->       3  |   | |_|
+   *    4  |_____|                   4  |___|_|
+   *    6                            6
+   *    7                            7
+   *
+   *
+   * In the following example, 2 zones are contiguous.
+   * Applying recomputeZones will return only one zone:
+   *
+   *  ["B2:B3", "C2:D3"]               ["B2:D3"]
+   *
+   *       A B C D E                   A B C D E
+   *     1   _ ___                   1   _____
+   *     2  | |   |        --->      2  |     |
+   *     3  |_|___|                  3  |_____|
+   *     4                           4
+   *
+   *
+   * In the following example, we want to remove a zone
+   * from the ensemble. Applying recomputeZones will
+   * return the ensemble without the zone to remove:
+   *
+   *    remove ["C3:D3"]           ["B2:B4", "C2:D2",
+   *                                "C4:D4", "E2:E4"]
+   *
+   *       A B C D E F                 A B C D E F
+   *     1   _______                 1   _______
+   *     2  |       |       --->     2  | |___| |
+   *     3  |  xxx  |                3  | |___| |
+   *     4  |_______|                4  |_|___|_|
+   *     5                           5
+   *
+   *
+   * The exercise seems simple when we have only 2 zones.
+   * But with n zones and in a performant way, we want to
+   * avoid comparing each zone with all the others.
+   *
+   *
+   * ####################################################
+   * # Methodological approach
+   * ####################################################
+   *
+   * The methodological approach to avoid comparing each
+   * zone with all the others is to use a data structure
+   * that allow to quickly find which zones are
+   * overlapping with any other given zone.
+   *
+   * Here the idea is to profile the zones at the columns level.
+   *
+   * To do that, we propose to use a data structure
+   * composed of 2 parts:
+   * - profilesStartingPosition: a sorted number array
+   * indicating on which columns a new profile begins.
+   * - profiles: a map where the key is a column
+   * position (from profilesStartingPosition) and the
+   * value is a sorted number array representing a
+   * profile.
+   *
+   *
+   * See the following example:    here profileStartingPosition
+   *                               corresponds to [A,C,E,G,K]
+   *    A B C D E F G H I J K      so with number [0,2,4,6,10]
+   *  1    '   '   '       '
+   *  2    '   '   '_______'       here profile correspond
+   *  3    '___'   |_______|       for A to []
+   *  4    |   |                   for C to [3, 5]
+   *  5    |___|                   for E to []
+   *  6                            for G to [2, 3]
+   *  7                            for K to []
+   *
+   *
+   * Now we can easily find which zones are overlapping
+   * with a given zone. Suppose we want to add a new zone
+   * D5:H6 to the ensemble:
+   *
+   *                              With a binary search of left and right
+   *    A B C D E F G H I J K     on profilesStartingPosition, we can
+   *  1    '   '   '       '      find the indexes of the profiles on which
+   *  2    '   '   '_______'      to apply a modification.
+   *  3    '___'   |_______|
+   *  4    |  _|_______           Here we will:
+   *  5    |_|_|       |          - add a new profile in D   --> become [3, 6]
+   *  6      |_________|          - modify the profile in E  --> become [4, 6]
+   *  7                           - modify the profile in G  --> become [2, 3, 4, 6]
+   *                              - add a new profile in I   --> become [8, 10]
+   *
+   *  See below the result:
+   *
+   *                              Note the particularity of the profile
+   *    A B C D E F G H I J K     for G: it will correspond to [2, 3, 4, 6]
+   *  1    ' ' '   '   '   '
+   *  2    ' ' '   '___'___'      To know how to modify the profile (add a
+   *  3    '_'_'   |___|___|      zone or remove it) we do a binary
+   *  4    | | |___ ___           search of the top and bottom value on the
+   *  5    |_| |   |   |          profile array. Depending on the result index
+   *  6      |_|___|___|          parity (odd or even), because zone boundaries
+   *  7                           go by pairs, we know if we are in a zone or
+   *                              not and how operate.
+   */
+  /**
+   * Recompute the zone without the cells in toRemoveZones and avoid overlapping.
+   * This compute is particularly useful because after this function:
+   * - you will find coordinate of a cell only once among all the zones
+   * - the number of zones will be reduced to the minimum
+   */
+  function futureRecomputeZones(zones, zonesToRemove = []) {
+      const profilesStartingPosition = [0];
+      const profiles = new Map([[0, []]]);
+      modifyProfiles(profilesStartingPosition, profiles, zones, false);
+      modifyProfiles(profilesStartingPosition, profiles, zonesToRemove, true);
+      return constructZonesFromProfiles(profilesStartingPosition, profiles);
+  }
+  function modifyProfiles(// export for testing only
+  profilesStartingPosition, profiles, zones, toRemove = false) {
+      for (const zone of zones) {
+          const leftValue = zone.left;
+          const rightValue = zone.right === undefined ? undefined : zone.right + 1;
+          const leftIndex = findIndexAndCreateProfile(profilesStartingPosition, profiles, leftValue, true, 0);
+          const rightIndex = findIndexAndCreateProfile(profilesStartingPosition, profiles, rightValue, false, leftIndex);
+          for (let i = leftIndex; i <= rightIndex; i++) {
+              const profile = profiles.get(profilesStartingPosition[i]);
+              modifyProfile(profile, zone, toRemove);
+          }
+          // maybe this part cost in performance, and maybe it's not necessary (depending on the use case). To be checked
+          removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex);
+      }
+  }
+  function findIndexAndCreateProfile(profilesStartingPosition, profiles, value, searchLeft, startIndex) {
+      if (value === undefined) {
+          // this is only the case when the value correspond to a bottom value that could be undefined
+          return profilesStartingPosition.length - 1;
+      }
+      const predecessorIndex = binaryPredecessorSearch(profilesStartingPosition, value, startIndex);
+      if (value != profilesStartingPosition[predecessorIndex]) {
+          // mean that the value is not ending/starting at the same position as the previous/next profile
+          // --> it's a new profile
+          // --> we need to add it
+          profilesStartingPosition.splice(predecessorIndex + 1, 0, value);
+          // suppose the               we want to add the       for the left value
+          // following profile         following zone:          'C', the predecessor index
+          //   for B: [1, 3]                "C3:D4"             correspond to 'B'.
+          //                                                    The next line code will
+          //       A B C D                A B C D               copy the profile of 'B'
+          //     1  '___'               1  '___'                to 'C'. In the rest of the
+          //     2  |   |       --->    2  |  _|_               process the 'modifyProfile'
+          //     3  |___|               3  |_|_| |              function will adapt the waiting
+          //     4                      4    |___|              'C' profile [1, 3] to the
+          //                                                    correct 'C' profile [1, 4]
+          profiles.set(value, [...profiles.get(profilesStartingPosition[predecessorIndex])]);
+          return searchLeft ? predecessorIndex + 1 : predecessorIndex;
+      }
+      return searchLeft ? predecessorIndex : predecessorIndex - 1;
+  }
+  /**
+   *  Suppose the following        Suppose we want to add          We want to have the
+   *  profile:                     the following zone:             following profile:
+   *
+   *       A B C D E F                  A B C D E F                     A B C D E F
+   *     1    '___'                   1    '   '                      1    '___'
+   *     2    |___|                   2    '___'                      2    |   |
+   *     3    '   '                   3    |   |                      3    |   |
+   *     4    '___'          -->      4    |   |            -->       4    |   |
+   *     6    |   |                   6    |___|                      6    |   |
+   *     7    |___|                   7                               7    |___|
+   *     8                            8                               8
+   *
+   *  the profile for 'C'          the top zone correspond        Here [2, 3, 5, 8] with [3, 7]
+   *  corresponds to:              to 3 and the bottom zone       would be merged into [2, 8]
+   *   ____  ____                  correspond to 6
+   *  [2, 3, 5, 8]                 would be the profile:          The difficulty of modify profile
+   *                                ____                          is to know what must be deleted
+   *  Note that the 'filled        [3, 7]                         and what must be added to the
+   *  zone' are always between                                    existing profile.
+   *  an even index and its
+   *  next index
+   *
+   */
+  function modifyProfile(profile, zone, toRemove = false) {
+      const topValue = zone.top;
+      const bottomValue = zone.bottom === undefined ? undefined : zone.bottom + 1;
+      const newPoints = [];
+      // Case we want to add a zone to the profile:
+      // - If the top predecessor index `topPredIndex` is even, it means the top of the zone is already positioned on a filled zone
+      // so we don't need to add it to the profile. we can keep in reference the index of the predecessor.
+      // - If it is odd, it means the top of the zone must be the beginning of a filled zone.
+      // so we can keep the index of the top position
+      // Case we want to remove a zone from the profile: it's the opposite of the previous case
+      const topPredIndex = binaryPredecessorSearch(profile, topValue, 0, false);
+      if ((topPredIndex % 2 !== 0 && !toRemove) || (topPredIndex % 2 === 0 && toRemove)) {
+          newPoints.push(topValue);
+      }
+      if (bottomValue === undefined) {
+          // The following two code lines will not impact the final result,
+          // but they will impact the intermediate profile.
+          // We keep them for performance reason
+          profile.splice(topPredIndex + 1);
+          profile.push(...newPoints);
+          return;
+      }
+      // Case we want to add a zone to the profile:
+      // - If the bottom successor index `bottomSuccIndex` is even, it means the bottom of the zone must be the ending of a filled zone
+      // so we can keep the index of the bottom position.
+      // - If it is odd, it means the bottom of the zone is already positioned on a filled zone
+      // so we don't need to add it to the profile. we can keep in reference the index of the successor
+      // Case we want to remove a zone from the profile: it's the opposite of the previous case
+      const bottomSuccIndex = binarySuccessorSearch(profile, bottomValue, 0, false);
+      if ((bottomSuccIndex % 2 === 0 && !toRemove) || (bottomSuccIndex % 2 !== 0 && toRemove)) {
+          newPoints.push(bottomValue);
+      }
+      // add the top and bottom value to the profile and
+      // remove all information between the top and bottom index
+      profile.splice(topPredIndex + 1, bottomSuccIndex - topPredIndex - 1, ...newPoints);
+  }
+  function removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex) {
+      const start = leftIndex - 1 === -1 ? 0 : leftIndex - 1;
+      const end = rightIndex === profilesStartingPosition.length - 1 ? rightIndex : rightIndex + 1;
+      for (let i = end; i > start; i--) {
+          if (deepEqualsArray(profiles.get(profilesStartingPosition[i]), profiles.get(profilesStartingPosition[i - 1]))) {
+              profiles.delete(profilesStartingPosition[i]);
+              profilesStartingPosition.splice(i, 1);
+          }
+      }
+  }
+  function constructZonesFromProfiles(profilesStartingPosition, profiles) {
+      const mergedZone = [];
+      let pendingZones = [];
+      for (let colIndex = 0; colIndex < profilesStartingPosition.length; colIndex++) {
+          const left = profilesStartingPosition[colIndex];
+          const profile = profiles.get(left);
+          if (!profile || profile.length === 0) {
+              mergedZone.push(...pendingZones);
+              pendingZones = [];
+              continue;
+          }
+          let right = profilesStartingPosition[colIndex + 1];
+          if (right !== undefined) {
+              right--;
+          }
+          const nextPendingZones = [];
+          for (let i = 0; i < profile.length; i += 2) {
+              const top = profile[i];
+              let bottom = profile[i + 1];
+              if (bottom !== undefined) {
+                  bottom--;
+              }
+              const profileZone = {
+                  top,
+                  left,
+                  bottom,
+                  right,
+                  hasHeader: (bottom === undefined && top !== 0) || (right === undefined && left !== 0),
+              };
+              let findCorrespondingZone = false;
+              for (let j = pendingZones.length - 1; j >= 0; j--) {
+                  const pendingZone = pendingZones[j];
+                  if (pendingZone.top === profileZone.top && pendingZone.bottom === profileZone.bottom) {
+                      pendingZone.right = profileZone.right;
+                      pendingZones.splice(j, 1);
+                      nextPendingZones.push(pendingZone);
+                      findCorrespondingZone = true;
+                      break;
+                  }
+              }
+              if (!findCorrespondingZone) {
+                  nextPendingZones.push(profileZone);
+              }
+          }
+          mergedZone.push(...pendingZones);
+          pendingZones = nextPendingZones;
+      }
+      mergedZone.push(...pendingZones);
+      return mergedZone;
+  }
+  function binaryPredecessorSearch(arr, val, start = 0, matchEqual = true) {
+      let end = arr.length - 1;
+      let result = -1;
+      while (start <= end) {
+          const mid = Math.floor((start + end) / 2);
+          if (arr[mid] === val && matchEqual) {
+              return mid;
+          }
+          else if (arr[mid] < val) {
+              result = mid;
+              start = mid + 1;
+          }
+          else {
+              end = mid - 1;
+          }
+      }
+      return result;
+  }
+  function binarySuccessorSearch(arr, val, start = 0, matchEqual = true) {
+      let end = arr.length - 1;
+      let result = arr.length;
+      while (start <= end) {
+          const mid = Math.floor((start + end) / 2);
+          if (arr[mid] === val && matchEqual) {
+              return mid;
+          }
+          else if (arr[mid] > val) {
+              result = mid;
+              end = mid - 1;
+          }
+          else {
+              start = mid + 1;
+          }
+      }
+      return result;
+  }
+  /**
+   * Compares two arrays.
+   * For performance reasons, this function is to be preferred
+   * to 'deepEquals' in the case we know that the inputs are arrays.
+   */
+  function deepEqualsArray(arr1, arr2) {
+      if (arr1.length !== arr2.length) {
+          return false;
+      }
+      for (let i = 0; i < arr1.length; i++) {
+          if (!deepEquals(arr1[i], arr2[i])) {
+              return false;
+          }
+      }
+      return true;
+  }
+
   // -----------------------------------------------------------------------------
   // Constants
   // -----------------------------------------------------------------------------
@@ -36859,10 +37223,12 @@
           const replaceIndex = rules.findIndex((c) => c.id === cf.id);
           let currentRanges = [];
           if (replaceIndex > -1) {
-              currentRanges = rules[replaceIndex].ranges;
+              currentRanges = rules[replaceIndex].ranges.map(toUnboundedZone);
           }
           currentRanges = currentRanges.concat(toAdd);
-          return recomputeZones(currentRanges, toRemove);
+          // Remove the zones first in case the same position is in toAdd and toRemove
+          const withRemovedZones = futureRecomputeZones(currentRanges, toRemove);
+          return futureRecomputeZones([...toAdd, ...withRemovedZones], []);
       }
       // ---------------------------------------------------------------------------
       // Private
@@ -40597,353 +40963,6 @@
       }
   }
 
-  /**
-   * ####################################################
-   * # INTRODUCTION
-   * ####################################################
-   *
-   * This file contain the function recomputeZones.
-   * This function try to recompute in a performant way
-   * an ensemble of zones possibly overlapping to avoid
-   * overlapping and to reduce the number of zones.
-   *
-   * It also allows to remove some zones from the ensemble.
-   *
-   * In the following example, 2 zones are overlapping.
-   * Applying recomputeZones will return zones without
-   * overlapping:
-   *
-   * ["B3:D4", "D2:E3"]         ["B3:C4", "D2:D4", "E2:E3"]
-   *
-   *      A B C D E                    A B C D E
-   *    1       ___                  1       ___
-   *    2   ___|_  |                 2   ___| | |
-   *    3  |   |_|_|      --->       3  |   | |_|
-   *    4  |_____|                   4  |___|_|
-   *    6                            6
-   *    7                            7
-   *
-   *
-   * In the following example, 2 zones are contiguous.
-   * Applying recomputeZones will return only one zone:
-   *
-   *  ["B2:B3", "C2:D3"]               ["B2:D3"]
-   *
-   *       A B C D E                   A B C D E
-   *     1   _ ___                   1   _____
-   *     2  | |   |        --->      2  |     |
-   *     3  |_|___|                  3  |_____|
-   *     4                           4
-   *
-   *
-   * In the following example, we want to remove a zone
-   * from the ensemble. Applying recomputeZones will
-   * return the ensemble without the zone to remove:
-   *
-   *    remove ["C3:D3"]           ["B2:B4", "C2:D2",
-   *                                "C4:D4", "E2:E4"]
-   *
-   *       A B C D E F                 A B C D E F
-   *     1   _______                 1   _______
-   *     2  |       |       --->     2  | |___| |
-   *     3  |  xxx  |                3  | |___| |
-   *     4  |_______|                4  |_|___|_|
-   *     5                           5
-   *
-   *
-   * The exercise seems simple when we have only 2 zones.
-   * But with n zones and in a performant way, we want to
-   * avoid comparing each zone with all the others.
-   *
-   *
-   * ####################################################
-   * # Methodological approach
-   * ####################################################
-   *
-   * The methodological approach to avoid comparing each
-   * zone with all the others is to use a data structure
-   * that allow to quickly find which zones are
-   * overlapping with any other given zone.
-   *
-   * Here the idea is to profile the zones at the columns level.
-   *
-   * To do that, we propose to use a data structure
-   * composed of 2 parts:
-   * - profilesStartingPosition: a sorted number array
-   * indicating on which columns a new profile begins.
-   * - profiles: a map where the key is a column
-   * position (from profilesStartingPosition) and the
-   * value is a sorted number array representing a
-   * profile.
-   *
-   *
-   * See the following example:    here profileStartingPosition
-   *                               corresponds to [A,C,E,G,K]
-   *    A B C D E F G H I J K      so with number [0,2,4,6,10]
-   *  1    '   '   '       '
-   *  2    '   '   '_______'       here profile correspond
-   *  3    '___'   |_______|       for A to []
-   *  4    |   |                   for C to [3, 5]
-   *  5    |___|                   for E to []
-   *  6                            for G to [2, 3]
-   *  7                            for K to []
-   *
-   *
-   * Now we can easily find which zones are overlapping
-   * with a given zone. Suppose we want to add a new zone
-   * D5:H6 to the ensemble:
-   *
-   *                              With a binary search of left and right
-   *    A B C D E F G H I J K     on profilesStartingPosition, we can
-   *  1    '   '   '       '      find the indexes of the profiles on which
-   *  2    '   '   '_______'      to apply a modification.
-   *  3    '___'   |_______|
-   *  4    |  _|_______           Here we will:
-   *  5    |_|_|       |          - add a new profile in D   --> become [3, 6]
-   *  6      |_________|          - modify the profile in E  --> become [4, 6]
-   *  7                           - modify the profile in G  --> become [2, 3, 4, 6]
-   *                              - add a new profile in I   --> become [8, 10]
-   *
-   *  See below the result:
-   *
-   *                              Note the particularity of the profile
-   *    A B C D E F G H I J K     for G: it will correspond to [2, 3, 4, 6]
-   *  1    ' ' '   '   '   '
-   *  2    ' ' '   '___'___'      To know how to modify the profile (add a
-   *  3    '_'_'   |___|___|      zone or remove it) we do a binary
-   *  4    | | |___ ___           search of the top and bottom value on the
-   *  5    |_| |   |   |          profile array. Depending on the result index
-   *  6      |_|___|___|          parity (odd or even), because zone boundaries
-   *  7                           go by pairs, we know if we are in a zone or
-   *                              not and how operate.
-   */
-  /**
-   * Recompute the zone without the cells in toRemoveZones and avoid overlapping.
-   * This compute is particularly useful because after this function:
-   * - you will find coordinate of a cell only once among all the zones
-   * - the number of zones will be reduced to the minimum
-   */
-  function futureRecomputeZones(zones, zonesToRemove = []) {
-      const profilesStartingPosition = [0];
-      const profiles = new Map([[0, []]]);
-      modifyProfiles(profilesStartingPosition, profiles, zones, false);
-      modifyProfiles(profilesStartingPosition, profiles, zonesToRemove, true);
-      return constructZonesFromProfiles(profilesStartingPosition, profiles);
-  }
-  function modifyProfiles(// export for testing only
-  profilesStartingPosition, profiles, zones, toRemove = false) {
-      for (const zone of zones) {
-          const leftValue = zone.left;
-          const rightValue = zone.right === undefined ? undefined : zone.right + 1;
-          const leftIndex = findIndexAndCreateProfile(profilesStartingPosition, profiles, leftValue, true, 0);
-          const rightIndex = findIndexAndCreateProfile(profilesStartingPosition, profiles, rightValue, false, leftIndex);
-          for (let i = leftIndex; i <= rightIndex; i++) {
-              const profile = profiles.get(profilesStartingPosition[i]);
-              modifyProfile(profile, zone, toRemove);
-          }
-          // maybe this part cost in performance, and maybe it's not necessary (depending on the use case). To be checked
-          removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex);
-      }
-  }
-  function findIndexAndCreateProfile(profilesStartingPosition, profiles, value, searchLeft, startIndex) {
-      if (value === undefined) {
-          // this is only the case when the value correspond to a bottom value that could be undefined
-          return profilesStartingPosition.length - 1;
-      }
-      const predecessorIndex = binaryPredecessorSearch(profilesStartingPosition, value, startIndex);
-      if (value != profilesStartingPosition[predecessorIndex]) {
-          // mean that the value is not ending/starting at the same position as the previous/next profile
-          // --> it's a new profile
-          // --> we need to add it
-          profilesStartingPosition.splice(predecessorIndex + 1, 0, value);
-          // suppose the               we want to add the       for the left value
-          // following profile         following zone:          'C', the predecessor index
-          //   for B: [1, 3]                "C3:D4"             correspond to 'B'.
-          //                                                    The next line code will
-          //       A B C D                A B C D               copy the profile of 'B'
-          //     1  '___'               1  '___'                to 'C'. In the rest of the
-          //     2  |   |       --->    2  |  _|_               process the 'modifyProfile'
-          //     3  |___|               3  |_|_| |              function will adapt the waiting
-          //     4                      4    |___|              'C' profile [1, 3] to the
-          //                                                    correct 'C' profile [1, 4]
-          profiles.set(value, [...profiles.get(profilesStartingPosition[predecessorIndex])]);
-          return searchLeft ? predecessorIndex + 1 : predecessorIndex;
-      }
-      return searchLeft ? predecessorIndex : predecessorIndex - 1;
-  }
-  /**
-   *  Suppose the following        Suppose we want to add          We want to have the
-   *  profile:                     the following zone:             following profile:
-   *
-   *       A B C D E F                  A B C D E F                     A B C D E F
-   *     1    '___'                   1    '   '                      1    '___'
-   *     2    |___|                   2    '___'                      2    |   |
-   *     3    '   '                   3    |   |                      3    |   |
-   *     4    '___'          -->      4    |   |            -->       4    |   |
-   *     6    |   |                   6    |___|                      6    |   |
-   *     7    |___|                   7                               7    |___|
-   *     8                            8                               8
-   *
-   *  the profile for 'C'          the top zone correspond        Here [2, 3, 5, 8] with [3, 7]
-   *  corresponds to:              to 3 and the bottom zone       would be merged into [2, 8]
-   *   ____  ____                  correspond to 6
-   *  [2, 3, 5, 8]                 would be the profile:          The difficulty of modify profile
-   *                                ____                          is to know what must be deleted
-   *  Note that the 'filled        [3, 7]                         and what must be added to the
-   *  zone' are always between                                    existing profile.
-   *  an even index and its
-   *  next index
-   *
-   */
-  function modifyProfile(profile, zone, toRemove = false) {
-      const topValue = zone.top;
-      const bottomValue = zone.bottom === undefined ? undefined : zone.bottom + 1;
-      const newPoints = [];
-      // Case we want to add a zone to the profile:
-      // - If the top predecessor index `topPredIndex` is even, it means the top of the zone is already positioned on a filled zone
-      // so we don't need to add it to the profile. we can keep in reference the index of the predecessor.
-      // - If it is odd, it means the top of the zone must be the beginning of a filled zone.
-      // so we can keep the index of the top position
-      // Case we want to remove a zone from the profile: it's the opposite of the previous case
-      const topPredIndex = binaryPredecessorSearch(profile, topValue, 0, false);
-      if ((topPredIndex % 2 !== 0 && !toRemove) || (topPredIndex % 2 === 0 && toRemove)) {
-          newPoints.push(topValue);
-      }
-      if (bottomValue === undefined) {
-          // The following two code lines will not impact the final result,
-          // but they will impact the intermediate profile.
-          // We keep them for performance reason
-          profile.splice(topPredIndex + 1);
-          profile.push(...newPoints);
-          return;
-      }
-      // Case we want to add a zone to the profile:
-      // - If the bottom successor index `bottomSuccIndex` is even, it means the bottom of the zone must be the ending of a filled zone
-      // so we can keep the index of the bottom position.
-      // - If it is odd, it means the bottom of the zone is already positioned on a filled zone
-      // so we don't need to add it to the profile. we can keep in reference the index of the successor
-      // Case we want to remove a zone from the profile: it's the opposite of the previous case
-      const bottomSuccIndex = binarySuccessorSearch(profile, bottomValue, 0, false);
-      if ((bottomSuccIndex % 2 === 0 && !toRemove) || (bottomSuccIndex % 2 !== 0 && toRemove)) {
-          newPoints.push(bottomValue);
-      }
-      // add the top and bottom value to the profile and
-      // remove all information between the top and bottom index
-      profile.splice(topPredIndex + 1, bottomSuccIndex - topPredIndex - 1, ...newPoints);
-  }
-  function removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex) {
-      const start = leftIndex - 1 === -1 ? 0 : leftIndex - 1;
-      const end = rightIndex === profilesStartingPosition.length - 1 ? rightIndex : rightIndex + 1;
-      for (let i = end; i > start; i--) {
-          if (deepEqualsArray(profiles.get(profilesStartingPosition[i]), profiles.get(profilesStartingPosition[i - 1]))) {
-              profiles.delete(profilesStartingPosition[i]);
-              profilesStartingPosition.splice(i, 1);
-          }
-      }
-  }
-  function constructZonesFromProfiles(profilesStartingPosition, profiles) {
-      const mergedZone = [];
-      let pendingZones = [];
-      for (let colIndex = 0; colIndex < profilesStartingPosition.length; colIndex++) {
-          const left = profilesStartingPosition[colIndex];
-          const profile = profiles.get(left);
-          if (!profile || profile.length === 0) {
-              mergedZone.push(...pendingZones);
-              pendingZones = [];
-              continue;
-          }
-          let right = profilesStartingPosition[colIndex + 1];
-          if (right !== undefined) {
-              right--;
-          }
-          const nextPendingZones = [];
-          for (let i = 0; i < profile.length; i += 2) {
-              const top = profile[i];
-              let bottom = profile[i + 1];
-              if (bottom !== undefined) {
-                  bottom--;
-              }
-              const profileZone = {
-                  top,
-                  left,
-                  bottom,
-                  right,
-                  hasHeader: (bottom === undefined && top !== 0) || (right === undefined && left !== 0),
-              };
-              let findCorrespondingZone = false;
-              for (let j = pendingZones.length - 1; j >= 0; j--) {
-                  const pendingZone = pendingZones[j];
-                  if (pendingZone.top === profileZone.top && pendingZone.bottom === profileZone.bottom) {
-                      pendingZone.right = profileZone.right;
-                      pendingZones.splice(j, 1);
-                      nextPendingZones.push(pendingZone);
-                      findCorrespondingZone = true;
-                      break;
-                  }
-              }
-              if (!findCorrespondingZone) {
-                  nextPendingZones.push(profileZone);
-              }
-          }
-          mergedZone.push(...pendingZones);
-          pendingZones = nextPendingZones;
-      }
-      mergedZone.push(...pendingZones);
-      return mergedZone;
-  }
-  function binaryPredecessorSearch(arr, val, start = 0, matchEqual = true) {
-      let end = arr.length - 1;
-      let result = -1;
-      while (start <= end) {
-          const mid = Math.floor((start + end) / 2);
-          if (arr[mid] === val && matchEqual) {
-              return mid;
-          }
-          else if (arr[mid] < val) {
-              result = mid;
-              start = mid + 1;
-          }
-          else {
-              end = mid - 1;
-          }
-      }
-      return result;
-  }
-  function binarySuccessorSearch(arr, val, start = 0, matchEqual = true) {
-      let end = arr.length - 1;
-      let result = arr.length;
-      while (start <= end) {
-          const mid = Math.floor((start + end) / 2);
-          if (arr[mid] === val && matchEqual) {
-              return mid;
-          }
-          else if (arr[mid] > val) {
-              result = mid;
-              end = mid - 1;
-          }
-          else {
-              start = mid + 1;
-          }
-      }
-      return result;
-  }
-  /**
-   * Compares two arrays.
-   * For performance reasons, this function is to be preferred
-   * to 'deepEquals' in the case we know that the inputs are arrays.
-   */
-  function deepEqualsArray(arr1, arr2) {
-      if (arr1.length !== arr2.length) {
-          return false;
-      }
-      for (let i = 0; i < arr1.length; i++) {
-          if (!deepEquals(arr1[i], arr2[i])) {
-              return false;
-          }
-      }
-      return true;
-  }
-
   function quickselect(arr, k, left, right, compare) {
       quickselectStep(arr, k, left || 0, right || (arr.length - 1), compare || defaultCompare);
   }
@@ -43540,25 +43559,6 @@
               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);
           }
       }
       // ---------------------------------------------------------------------------
@@ -43582,6 +43582,7 @@
           }
           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++) {
@@ -43591,7 +43592,7 @@
                       }
                       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;
@@ -43603,7 +43604,7 @@
                       }
                       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;
@@ -43615,7 +43616,7 @@
                       }
                       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;
@@ -43627,12 +43628,26 @@
                       }
                       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 = {};
@@ -43641,6 +43656,95 @@
               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: futureRecomputeZones(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 newCfZones = this.getters.getAdaptedCfRanges(sheetId, cf, changes.map(toZone), []);
+              if (newCfZones) {
+                  this.dispatch("ADD_CONDITIONAL_FORMAT", {
+                      cf: {
+                          id: cf.id,
+                          rule: cf.rule,
+                          stopIfTrue: cf.stopIfTrue,
+                      },
+                      ranges: newCfZones.map((xc) => this.getters.getRangeDataFromZone(sheetId, xc)),
+                      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 = futureRecomputeZones(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
        */
@@ -43707,22 +43811,20 @@
       /**
        * 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
@@ -43790,8 +43892,8 @@
               ? 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)) {
@@ -43818,35 +43920,6 @@
               });
           }
       }
-      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, [toXC(col, row)], []);
-              if (newCfRanges) {
-                  this.dispatch("ADD_CONDITIONAL_FORMAT", {
-                      cf: deepCopy(cf),
-                      ranges: newCfRanges.map((xc) => this.getters.getRangeDataFromXc(sheetId, xc)),
-                      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 dvRangesXcs = dvOrigin.ranges.map((range) => this.getters.getRangeString(range, sheetId));
-          const newDvRanges = recomputeZones(dvRangesXcs.concat(toXC(col, row)), []);
-          this.dispatch("ADD_DATA_VALIDATION_RULE", {
-              rule: dvOrigin,
-              ranges: newDvRanges.map((xc) => this.getters.getRangeDataFromXc(sheetId, xc)),
-              sheetId,
-          });
-      }
       // ---------------------------------------------------------------------------
       // Grid rendering
       // ---------------------------------------------------------------------------
@@ -44344,10 +44417,8 @@
       }
       const target = [];
       for (const zone1 of toTransform.target) {
-          for (const zone2 of executed.target) {
-              if (!overlap(zone1, zone2)) {
-                  target.push({ ...zone1 });
-              }
+          if (executed.target.every((zone2) => !overlap(zone1, zone2))) {
+              target.push(zone1);
           }
       }
       if (target.length) {
@@ -45233,6 +45304,9 @@
       copiedTables;
       zones;
       uuidGenerator = new UuidGenerator();
+      queuedBordersToAdd = {};
+      queuedCFChanges = {};
+      queuedDVChanges = {};
       constructor(zones, operation, getters, dispatch, selection) {
           super(operation, getters, dispatch, selection);
           if (!zones.length) {
@@ -45342,6 +45416,8 @@
        * Paste the clipboard content in the given target
        */
       paste(target, options) {
+          this.queuedCFChanges = {};
+          this.queuedDVChanges = {};
           if (this.operation === "COPY") {
               this.pasteFromCopy(target, options);
           }
@@ -45354,6 +45430,7 @@
           if (options?.selectTarget) {
               this.selectPastedZone(width, height, isCutOperation, target);
           }
+          this.executeQueuedChanges(this.getters.getActiveSheetId());
       }
       pasteFromCopy(target, options) {
           if (target.length === 1) {
@@ -45528,7 +45605,11 @@
               left: targetBorders?.left || originBorders?.left,
               right: targetBorders?.right || originBorders?.right,
           };
-          this.dispatch("SET_BORDER", { sheetId, col, row, border });
+          const borderKey = JSON.stringify(border);
+          if (!this.queuedBordersToAdd[borderKey]) {
+              this.queuedBordersToAdd[borderKey] = [];
+          }
+          this.queuedBordersToAdd[borderKey].push(positionToZone(target));
           if (clipboardOption?.pasteOption === "onlyFormat") {
               this.dispatch("UPDATE_CELL", {
                   ...target,
@@ -45674,7 +45755,8 @@
           }
       }
       pasteCf(origin, target) {
-          const xc = toXC(target.col, target.row);
+          const zone = positionToZone(target);
+          const originZone = positionToZone(origin);
           for (let rule of this.getters.getConditionalFormats(origin.sheetId)) {
               for (let range of rule.ranges) {
                   if (isInside(origin.col, origin.row, this.getters.getRangeFromSheetXC(origin.sheetId, range).zone)) {
@@ -45682,15 +45764,15 @@
                       const toRemoveRange = [];
                       if (this.operation === "CUT") {
                           //remove from current rule
-                          toRemoveRange.push(toXC(origin.col, origin.row));
+                          toRemoveRange.push(originZone);
                       }
                       if (origin.sheetId === target.sheetId) {
-                          this.adaptCFRules(origin.sheetId, cf, [xc], toRemoveRange);
+                          this.adaptCFRules(origin.sheetId, cf, [zone], toRemoveRange);
                       }
                       else {
                           this.adaptCFRules(origin.sheetId, cf, [], toRemoveRange);
                           const cfToCopyTo = this.getCFToCopyTo(target.sheetId, cf);
-                          this.adaptCFRules(target.sheetId, cfToCopyTo, [xc], []);
+                          this.adaptCFRules(target.sheetId, cfToCopyTo, [zone], []);
                       }
                   }
               }
@@ -45700,79 +45782,130 @@
        * 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.queuedCFChanges[sheetId]) {
+              this.queuedCFChanges[sheetId] = [];
           }
-          if (newRangesXC.length === 0) {
-              this.dispatch("REMOVE_CONDITIONAL_FORMAT", { id: cf.id, sheetId });
-              return;
+          const queuedChange = this.queuedCFChanges[sheetId].find((queued) => queued.cf.id === cf.id);
+          if (!queuedChange) {
+              this.queuedCFChanges[sheetId].push({ toAdd, toRemove, cf });
+          }
+          else {
+              queuedChange.toAdd.push(...toAdd);
+              queuedChange.toRemove.push(...toRemove);
           }
-          this.dispatch("ADD_CONDITIONAL_FORMAT", {
-              cf: {
-                  id: cf.id,
-                  rule: cf.rule,
-                  stopIfTrue: cf.stopIfTrue,
-              },
-              ranges: newRangesXC.map((xc) => this.getters.getRangeDataFromXc(sheetId, xc)),
-              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.queuedCFChanges[targetSheetId];
+          if (!targetCF && queuedCfs) {
+              targetCF = queuedCfs.find((queued) => queued.cf.stopIfTrue === originCF.stopIfTrue && deepEquals(queued.cf.rule, originCF.rule))?.cf;
+          }
+          return targetCF ? targetCF : { ...originCF, id: this.uuidGenerator.smallUuid(), ranges: [] };
       }
       pasteDataValidation(origin, target) {
           const rule = this.getters.getValidationRuleForCell(origin);
+          const originZone = positionToZone(origin);
           if (!rule) {
               return;
           }
-          const xc = toXC(target.col, target.row);
+          const zone = positionToZone(target);
           for (const range of rule.ranges) {
               if (isInside(origin.col, origin.row, range.zone)) {
                   const toRemoveRange = [];
                   if (this.operation === "CUT") {
-                      toRemoveRange.push(toXC(origin.col, origin.row));
+                      toRemoveRange.push(originZone);
                   }
                   if (origin.sheetId === target.sheetId) {
-                      this.adaptDataValidationRule(origin.sheetId, rule, [xc], toRemoveRange);
+                      const copyToRule = this.getDataValidationRuleToCopyTo(target.sheetId, rule);
+                      this.adaptDataValidationRule(origin.sheetId, copyToRule, [zone], toRemoveRange);
                   }
                   else {
-                      this.adaptDataValidationRule(origin.sheetId, rule, [], toRemoveRange);
-                      let copyToRule = this.getDataValidationRuleToCopyTo(target.sheetId, rule);
-                      this.adaptDataValidationRule(target.sheetId, copyToRule, [xc], []);
+                      const originRule = this.getters.getValidationRuleForCell(origin);
+                      if (originRule) {
+                          this.adaptDataValidationRule(origin.sheetId, originRule, [], toRemoveRange);
+                      }
+                      const copyToRule = this.getDataValidationRuleToCopyTo(target.sheetId, rule);
+                      this.adaptDataValidationRule(target.sheetId, copyToRule, [zone], []);
                   }
               }
           }
       }
       getDataValidationRuleToCopyTo(targetSheetId, originRule) {
-          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: this.uuidGenerator.smallUuid(), ranges: [] };
+          const queuedRules = this.queuedDVChanges[targetSheetId];
+          if (!targetRule && queuedRules) {
+              targetRule = queuedRules.find((queued) => deepEquals(originRule.criterion, queued.rule.criterion) &&
+                  originRule.isBlocking === queued.rule.isBlocking)?.rule;
+          }
+          return targetRule || { ...originRule, id: this.uuidGenerator.smallUuid(), ranges: [] };
       }
       /**
        * Add or remove XCs to a given data validation rule.
        */
       adaptDataValidationRule(sheetId, rule, toAdd, toRemove) {
-          const dvRangesXcs = rule.ranges.map((range) => this.getters.getRangeString(range, sheetId));
-          const newRangesXC = recomputeZones([...dvRangesXcs, ...toAdd], toRemove);
-          if (newRangesXC.length === 0) {
-              this.dispatch("REMOVE_DATA_VALIDATION_RULE", { sheetId, id: rule.id });
-              return;
+          if (!this.queuedDVChanges[sheetId]) {
+              this.queuedDVChanges[sheetId] = [];
           }
-          this.dispatch("ADD_DATA_VALIDATION_RULE", {
-              rule,
-              ranges: newRangesXC.map((xc) => this.getters.getRangeDataFromXc(sheetId, xc)),
-              sheetId,
-          });
+          const queuedChange = this.queuedDVChanges[sheetId].find((queued) => queued.rule.id === rule.id);
+          if (!queuedChange) {
+              this.queuedDVChanges[sheetId].push({ toAdd, toRemove, rule: deepCopy(rule) });
+          }
+          else {
+              queuedChange.toAdd.push(...toAdd);
+              queuedChange.toRemove.push(...toRemove);
+          }
+      }
+      executeQueuedChanges(pasteSheetTarget) {
+          for (const sheetId in this.queuedCFChanges) {
+              for (const { toAdd, toRemove, cf } of this.queuedCFChanges[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.map((zone) => this.getters.getRangeDataFromZone(sheetId, zone)),
+                      sheetId,
+                  });
+              }
+          }
+          for (const sheetId in this.queuedDVChanges) {
+              for (const { toAdd, toRemove, rule: dv } of this.queuedDVChanges[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 = futureRecomputeZones(dvZones, toRemove);
+                  const newDvZones = futureRecomputeZones([...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,
+                  });
+              }
+          }
+          for (const borderKey in this.queuedBordersToAdd) {
+              const zones = this.queuedBordersToAdd[borderKey];
+              const border = JSON.parse(borderKey);
+              const target = futureRecomputeZones(zones, []);
+              this.dispatch("SET_BORDERS_ON_TARGET", { sheetId: pasteSheetTarget, target, border });
+          }
+          this.queuedBordersToAdd = {};
       }
   }
 
@@ -58120,9 +58253,9 @@
   exports.tokenize = tokenize;
 
 
-  __info__.version = "17.0.56";
-  __info__.date = "2025-04-04T08:36:58.258Z";
-  __info__.hash = "c484787";
+  __info__.version = "17.0.58";
+  __info__.date = "2025-04-18T16:20:26.099Z";
+  __info__.hash = "88d92de";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);