@odoo/o-spreadsheet 17.1.12 → 17.1.14

package/dist/o-spreadsheet.esm.js

@@ -2,12 +2,12 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.1.12
- * @date 2024-04-18T16:45:30.109Z
- * @hash 3e90776
+ * @version 17.1.14
+ * @date 2024-05-07T10:41:25.690Z
+ * @hash 622c47c
  */
 
-import { Component, useRef, onMounted, useEffect, onWillPatch, useState, onWillUpdateProps, onPatched, useComponent, useExternalListener, onWillUnmount, onWillStart, xml, useChildSubEnv, useSubEnv, markRaw } from '@odoo/owl';
+import { Component, useRef, onMounted, onWillUnmount, useEffect, onWillPatch, useState, onWillUpdateProps, onPatched, useComponent, useExternalListener, onWillStart, xml, useChildSubEnv, useSubEnv, markRaw } from '@odoo/owl';
 
 const CANVAS_SHIFT = 0.5;
 // Colors
@@ -541,7 +541,7 @@ function getAddHeaderStartIndex(position, base) {
 /**
  * Compares two objects.
  */
-function deepEquals(o1, o2) {
+function deepEquals(o1, o2, ignoreFunctions) {
     if (o1 === o2)
         return true;
     if ((o1 && !o2) || (o2 && !o1))
@@ -557,13 +557,16 @@ function deepEquals(o1, o2) {
         }
     }
     for (const key in o1) {
-        if (typeof o1[key] !== typeof o2[key])
+        const typeOfO1Key = typeof o1[key];
+        if (typeOfO1Key !== typeof o2[key])
             return false;
-        if (typeof o1[key] === "object") {
-            if (!deepEquals(o1[key], o2[key]))
+        if (typeOfO1Key === "object") {
+            if (!deepEquals(o1[key], o2[key], ignoreFunctions))
                 return false;
         }
         else {
+            if (ignoreFunctions && typeOfO1Key === "function")
+                return true;
             if (o1[key] !== o2[key])
                 return false;
         }
@@ -3623,21 +3626,22 @@ function toZoneWithoutBoundaryChanges(xc) {
         xc = xc.split("!").at(-1);
     }
     if (xc.includes("$")) {
-        xc = xc.replace(/\$/g, "");
+        xc = xc.replaceAll("$", "");
     }
-    let ranges;
+    let firstRangePart = "";
+    let secondRangePart;
     if (xc.includes(":")) {
-        ranges = xc.split(":").map((x) => x.trim());
+        [firstRangePart, secondRangePart] = xc.split(":");
+        firstRangePart = firstRangePart.trim();
+        secondRangePart = secondRangePart.trim();
     }
     else {
-        ranges = [xc.trim()];
+        firstRangePart = xc.trim();
     }
     let top, bottom, left, right;
     let fullCol = false;
     let fullRow = false;
     let hasHeader = false;
-    const firstRangePart = ranges[0];
-    const secondRangePart = ranges[1] && ranges[1];
     if (isColReference(firstRangePart)) {
         left = right = lettersToNumber(firstRangePart);
         top = bottom = 0;
@@ -3654,7 +3658,7 @@ function toZoneWithoutBoundaryChanges(xc) {
         top = bottom = c.row;
         hasHeader = true;
     }
-    if (ranges.length === 2) {
+    if (secondRangePart) {
         if (isColReference(secondRangePart)) {
             right = lettersToNumber(secondRangePart);
             fullCol = true;
@@ -4828,6 +4832,7 @@ class ChartJsComponent extends Component {
     };
     canvas = useRef("graphContainer");
     chart;
+    currentRuntime;
     get background() {
         return this.chartRuntime.background;
     }
@@ -4844,9 +4849,18 @@ class ChartJsComponent extends Component {
     setup() {
         onMounted(() => {
             const runtime = this.chartRuntime;
-            this.createChart(runtime.chartJsConfig);
+            this.currentRuntime = runtime;
+            // Note: chartJS modify the runtime in place, so it's important to give it a copy
+            this.createChart(deepCopy(runtime.chartJsConfig));
+        });
+        onWillUnmount(() => this.chart?.destroy());
+        useEffect(() => {
+            const runtime = this.chartRuntime;
+            if (!deepEquals(runtime, this.currentRuntime, "ignoreFunctions")) {
+                this.currentRuntime = runtime;
+                this.updateChartJs(deepCopy(runtime));
+            }
         });
-        useEffect(() => this.updateChartJs(this.chartRuntime), () => [this.chartRuntime]);
     }
     createChart(chartData) {
         const canvas = this.canvas.el;
@@ -4874,8 +4888,7 @@ class ChartJsComponent extends Component {
         this.chart.config.options.plugins.tooltip = chartData.options.plugins.tooltip;
         this.chart.config.options.plugins.legend = chartData.options.plugins.legend;
         this.chart.config.options.scales = chartData.options?.scales;
-        // ?
-        this.chart.update("active");
+        this.chart.update();
     }
 }
 
@@ -8438,7 +8451,7 @@ function truncateLabel(label) {
 /**
  * Get a default chart js configuration
  */
-function getDefaultChartJsRuntime(chart, labels, fontColor, { format, locale }) {
+function getDefaultChartJsRuntime(chart, labels, fontColor, { format, locale, truncateLabels }) {
     const options = {
         // https://www.chartjs.org/docs/latest/general/responsive.html
         responsive: true,
@@ -8485,7 +8498,7 @@ function getDefaultChartJsRuntime(chart, labels, fontColor, { format, locale })
         type: chart.type,
         options,
         data: {
-            labels: labels.map(truncateLabel),
+            labels: truncateLabels ? labels.map(truncateLabel) : labels,
             datasets: [],
         },
         platform: undefined,
@@ -9368,9 +9381,9 @@ function canBeLinearChart(labelRange, getters) {
     }
     return true;
 }
-function getLineConfiguration(chart, labels, localeFormat) {
+function getLineConfiguration(chart, labels, options) {
     const fontColor = chartFontColor(chart.background);
-    const config = getDefaultChartJsRuntime(chart, labels, fontColor, localeFormat);
+    const config = getDefaultChartJsRuntime(chart, labels, fontColor, options);
     const legend = {
         labels: {
             color: fontColor,
@@ -9413,7 +9426,7 @@ function getLineConfiguration(chart, labels, localeFormat) {
                     value = Number(value);
                     if (isNaN(value))
                         return value;
-                    const { locale, format } = localeFormat;
+                    const { locale, format } = options;
                     return formatValue(value, {
                         locale,
                         format: !format && Math.abs(value) >= 1000 ? "#,##" : format,
@@ -9446,9 +9459,10 @@ function createLineChartRuntime(chart, getters) {
         ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
     }
     const locale = getters.getLocale();
+    const truncateLabels = axisType === "category";
     const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
-    const localeFormat = { format: dataSetFormat, locale };
-    const config = getLineConfiguration(chart, labels, localeFormat);
+    const options = { format: dataSetFormat, locale, truncateLabels };
+    const config = getLineConfiguration(chart, labels, options);
     const labelFormat = getChartLabelFormat(getters, chart.labelRange);
     if (axisType === "time") {
         const axis = {
@@ -27178,17 +27192,13 @@ class Composer extends Component {
                 this.env.focusableElement.setFocusableElement(el);
             }
             this.contentHelper.updateEl(el);
-            this.processTokenAtCursor();
         });
         useEffect(() => {
             this.processContent();
         });
-        onPatched(() => {
-            // Required because typing '=SUM' and double-clicking another cell leaves ShowProvider/ShowDescription true
-            if (this.env.model.getters.getEditionMode() === "inactive") {
-                this.processTokenAtCursor();
-            }
-        });
+        useEffect(() => {
+            this.processTokenAtCursor();
+        }, () => [this.env.model.getters.getEditionMode() !== "inactive"]);
     }
     // ---------------------------------------------------------------------------
     // Handlers
@@ -27626,6 +27636,7 @@ class Composer extends Component {
         const dataValidationAutocompleteValues = this.env.model.getters.getAutoCompleteDataValidationValues();
         if (!content.startsWith("=") && dataValidationAutocompleteValues.length) {
             this.showDataValidationAutocomplete(dataValidationAutocompleteValues);
+            return;
         }
         if (content.startsWith("=")) {
             const token = this.env.model.getters.getTokenAtCursor();
@@ -28055,7 +28066,8 @@ class DataValidationOverlay extends Component {
     get checkBoxCellPositions() {
         return this.env.model.getters
             .getVisibleCellPositions()
-            .filter(this.env.model.getters.isCellValidCheckbox);
+            .filter((position) => this.env.model.getters.isCellValidCheckbox(position) &&
+            !this.env.model.getters.isFilterHeader(position));
     }
     get listIconsCellPositions() {
         if (this.env.model.getters.isReadonly()) {
@@ -28063,7 +28075,8 @@ class DataValidationOverlay extends Component {
         }
         return this.env.model.getters
             .getVisibleCellPositions()
-            .filter(this.env.model.getters.cellHasListDataValidationIcon);
+            .filter((position) => this.env.model.getters.cellHasListDataValidationIcon(position) &&
+            !this.env.model.getters.isFilterHeader(position));
     }
 }
 
@@ -34868,7 +34881,7 @@ class BordersPlugin extends CorePlugin {
                 this.clearBorders(cmd.sheetId, cmd.target);
                 break;
             case "REMOVE_COLUMNS_ROWS":
-                for (let el of cmd.elements) {
+                for (let el of [...cmd.elements].sort((a, b) => b - a)) {
                     if (cmd.dimension === "COL") {
                         this.shiftBordersHorizontally(cmd.sheetId, el + 1, -1);
                     }
@@ -40624,6 +40637,353 @@ class CompilationParametersBuilder {
     }
 }
 
+/**
+ * ####################################################
+ * # 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);
 }
@@ -41387,7 +41747,7 @@ class FormulaDependencyGraph {
         }
     }
     /**
-     * Return the cell and all cells that depend on it,
+     * Return all the cells that depend on the provided ranges,
      * in the correct order they should be evaluated.
      * This is called a topological ordering (excluding cycles)
      */
@@ -41398,11 +41758,20 @@ class FormulaDependencyGraph {
             const range = queue.pop();
             visited.addMany(this.encoder.encodeBoundingBox(range));
             const impactedPositionIds = this.rTree.search(range).map((dep) => dep.data);
+            const nextInQueue = {};
             for (const positionId of impactedPositionIds) {
                 if (!visited.has(positionId)) {
-                    queue.push(this.encoder.decodeToBoundingBox(positionId));
+                    const { sheetId, zone } = this.encoder.decodeToBoundingBox(positionId);
+                    if (!nextInQueue[sheetId]) {
+                        nextInQueue[sheetId] = [];
+                    }
+                    nextInQueue[sheetId].push(zone);
                 }
             }
+            for (const sheetId in nextInQueue) {
+                const zones = futureRecomputeZones(nextInQueue[sheetId]);
+                queue.push(...zones.map((zone) => ({ sheetId, zone })));
+            }
         }
         visited.deleteMany(ranges.flatMap((r) => this.encoder.encodeBoundingBox(r)));
         return visited;
@@ -41560,7 +41929,7 @@ class Evaluator {
             }
             if (!content) {
                 // The previous content could have blocked some array formulas
-                impactedPositionIds.addMany(this.getArrayFormulasBlockedByOrSpreadingOn(positionId));
+                impactedPositionIds.addMany(this.getArrayFormulasBlockedBy(positionId));
             }
         }
         return impactedPositionIds;
@@ -41608,13 +41977,22 @@ class Evaluator {
         }
         return positionIds;
     }
-    getArrayFormulasBlockedByOrSpreadingOn(positionId) {
+    /**
+     * Return the position of formulas blocked by the given position
+     * as well as all their dependencies.
+     */
+    getArrayFormulasBlockedBy(positionId) {
         if (!this.spreadingRelations.hasArrayFormulaResult(positionId)) {
             return [];
         }
         const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(positionId);
         const cells = new JetSet(arrayFormulas);
-        cells.addMany(this.getCellsDependingOn(arrayFormulas));
+        const arrayFormulaPositionId = this.getArrayFormulaSpreadingOnId(positionId);
+        if (arrayFormulaPositionId) {
+            // ignore the formula spreading on the position. Keep only the blocked ones
+            cells.delete(arrayFormulaPositionId);
+        }
+        cells.addMany(this.getCellsDependingOn(cells));
         return cells;
     }
     nextPositionsToUpdate = new JetSet();
@@ -41768,7 +42146,7 @@ class Evaluator {
             }
             this.evaluatedCells.delete(child);
             this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([child]));
-            this.nextPositionsToUpdate.addMany(this.getArrayFormulasBlockedByOrSpreadingOn(child));
+            this.nextPositionsToUpdate.addMany(this.getArrayFormulasBlockedBy(child));
         }
         this.spreadingRelations.removeNode(positionId);
     }
@@ -42140,7 +42518,7 @@ class EvaluationPlugin extends UIPlugin {
                 ? getItemId(newFormat, data.formats)
                 : exportedCellData.format;
             let content;
-            if (isFormula && formulaCell instanceof FormulaCellWithDependencies) {
+            if (isExported && isFormula && formulaCell instanceof FormulaCellWithDependencies) {
                 content = formulaCell.contentWithFixedReferences;
             }
             else {
@@ -57318,6 +57696,6 @@ const constants = {
 export { AbstractChart, CellErrorType, CommandResult, CorePlugin, DispatchResult, EvaluationError, Model, Registry, Revision, SPREADSHEET_DIMENSIONS, Spreadsheet, UIPlugin, __info__, addFunction, astToFormula, compile, compileTokens, components, constants, convertAstNodes, coreTypes, findCellInNewZone, functionCache, helpers, hooks, invalidateCFEvaluationCommands, invalidateDependenciesCommands, invalidateEvaluationCommands, iterateAstNodes, links, load, parse, parseTokens, readonlyAllowedCommands, registries, setDefaultSheetViewSize, setTranslationMethod, tokenize };
 
 
-__info__.version = "17.1.12";
-__info__.date = "2024-04-18T16:45:30.109Z";
-__info__.hash = "3e90776";
+__info__.version = "17.1.14";
+__info__.date = "2024-05-07T10:41:25.690Z";
+__info__.hash = "622c47c";