@odoo/o-spreadsheet 18.1.0-alpha.7 → 18.1.0-alpha.8

package/dist/o-spreadsheet.cjs.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 18.1.0-alpha.7
- * @date 2024-12-05T10:40:26.512Z
- * @hash 7b1c39b
+ * @version 18.1.0-alpha.8
+ * @date 2024-12-19T07:49:54.421Z
+ * @hash 87a1567
  */
 
 'use strict';
@@ -267,7 +267,6 @@ const MIN_ROW_HEIGHT = 10;
 const MIN_COL_WIDTH = 5;
 const HEADER_HEIGHT = 26;
 const HEADER_WIDTH = 48;
-const TOPBAR_HEIGHT = 63;
 const TOPBAR_TOOLBAR_HEIGHT = 34;
 const BOTTOMBAR_HEIGHT = 36;
 const DEFAULT_CELL_WIDTH = 96;
@@ -791,6 +790,7 @@ function removeFalsyAttributes(obj) {
  * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes
  */
 const whiteSpaceSpecialCharacters = [
+    " ",
     "\t",
     "\f",
     "\v",
@@ -805,17 +805,15 @@ const whiteSpaceSpecialCharacters = [
     String.fromCharCode(parseInt("3000", 16)),
     String.fromCharCode(parseInt("feff", 16)),
 ];
-const whiteSpaceRegexp = new RegExp(whiteSpaceSpecialCharacters.join("|") + "|(\r\n|\r|\n)", "g");
+const whiteSpaceRegexp = new RegExp(whiteSpaceSpecialCharacters.join("|"), "g");
+const newLineRegexp = /(\r\n|\r)/g;
 /**
- * Replace all the special spaces in a string (non-breaking, tabs, ...) by normal spaces, and all the
- * different newlines types by \n.
+ * Replace all different newlines characters by \n
  */
-function replaceSpecialSpaces(text) {
+function replaceNewLines(text) {
     if (!text)
         return "";
-    if (!whiteSpaceRegexp.test(text))
-        return text;
-    return text.replace(whiteSpaceRegexp, (match, newLine) => (newLine ? NEWLINE : " "));
+    return text.replace(newLineRegexp, NEWLINE);
 }
 /**
  * Determine if the numbers are consecutive.
@@ -981,7 +979,7 @@ function transpose2dPOJO(pojo) {
 
 const RBA_REGEX = /rgba?\(|\s+|\)/gi;
 const HEX_MATCH = /^#([A-F\d]{2}){3,4}$/;
-const colors$1 = [
+const colors = [
     "#eb6d00",
     "#0074d9",
     "#ad8e00",
@@ -1004,6 +1002,12 @@ const colors$1 = [
 function colorNumberString(color) {
     return toHex(color.toString(16).padStart(6, "0"));
 }
+function colorToNumber(color) {
+    if (typeof color === "number") {
+        return color;
+    }
+    return Number.parseInt(toHex(color).slice(1), 16);
+}
 /**
  * Converts any CSS color value to a standardized hex6 value.
  * Accepts: hex3, hex6, hex8, rgb[1] and rgba[1].
@@ -1354,9 +1358,9 @@ const COLORS_XL = [
     "#056BD9", // Blue #3
     "#155193", // Blue #4
     "#A76DBC", // Violet #1
-    "#7F4295", // Violet #1
-    "#6D2387", // Violet #1
-    "#4F1565", // Violet #1
+    "#7F4295", // Violet #2
+    "#6D2387", // Violet #3
+    "#4F1565", // Violet #4
     "#EA6175", // Red #1
     "#CE4257", // Red #2
     "#982738", // Red #3
@@ -1382,6 +1386,81 @@ const COLORS_XL = [
     "#C08A16", // Yellow #3
     "#936A12", // Yellow #4
 ];
+// Same as above but with alternating colors
+const ALTERNATING_COLORS_MD = [
+    "#4EA7F2", // Blue    #1
+    "#43C5B1", // Teal    #1
+    "#EA6175", // Red     #1
+    "#F4A261", // Orange  #1
+    "#8481DD", // Purple  #1
+    "#FFD86D", // Yellow  #1
+    "#3188E6", // Blue    #2
+    "#00A78D", // Teal    #2
+    "#CE4257", // Red     #2
+    "#F48935", // Orange  #2
+    "#5752D1", // Purple  #2
+    "#FFBC2C", // Yellow  #2
+];
+const ALTERNATING_COLORS_LG = [
+    "#4EA7F2", // Blue    #1
+    "#A76DBC", // Violet  #1
+    "#EA6175", // Red     #1
+    "#43C5B1", // Teal    #1
+    "#F4A261", // Orange  #1
+    "#8481DD", // Purple  #1
+    "#A4A8B6", // Gray    #1
+    "#FFD86D", // Yellow  #1
+    "#3188E6", // Blue    #2
+    "#7F4295", // Violet  #2
+    "#CE4257", // Red     #2
+    "#00A78D", // Teal    #2
+    "#F48935", // Orange  #2
+    "#5752D1", // Purple  #2
+    "#7E8290", // Gray    #2
+    "#FFBC2C", // Yellow  #2
+    "#056BD9", // Blue    #3
+    "#6D2387", // Violet  #3
+    "#982738", // Red     #3
+    "#0E8270", // Teal    #3
+    "#BE5D10", // Orange  #3
+    "#3A3580", // Purple  #3
+    "#545B70", // Gray    #3
+    "#C08A16", // Yellow  #3
+];
+const ALTERNATING_COLORS_XL = [
+    "#4EA7F2", // Blue    #1
+    "#A76DBC", // Violet  #1
+    "#EA6175", // Red     #1
+    "#43C5B1", // Teal    #1
+    "#F4A261", // Orange  #1
+    "#8481DD", // Purple  #1
+    "#A4A8B6", // Grey    #1
+    "#FFD86D", // Yellow  #1
+    "#3188E6", // Blue    #2
+    "#7F4295", // Violet  #2
+    "#CE4257", // Red     #2
+    "#00A78D", // Teal    #2
+    "#F48935", // Orange  #2
+    "#5752D1", // Purple  #2
+    "#7E8290", // Grey    #2
+    "#FFBC2C", // Yellow  #2
+    "#056BD9", // Blue    #3
+    "#6D2387", // Violet  #3
+    "#982738", // Red     #3
+    "#0E8270", // Teal    #3
+    "#BE5D10", // Orange  #3
+    "#3A3580", // Purple  #3
+    "#545B70", // Grey    #3
+    "#C08A16", // Yellow  #3
+    "#155193", // Blue    #4
+    "#4F1565", // Violet  #4
+    "#791B29", // Red     #4
+    "#105F53", // Teal    #4
+    "#7D380D", // Orange  #4
+    "#26235F", // Purple  #4
+    "#3F4250", // Grey    #4
+    "#936A12", // Yellow  #4
+];
 function getNthColor(index, palette) {
     return palette[index % palette.length];
 }
@@ -1399,6 +1478,20 @@ function getColorsPalette(quantity) {
         return COLORS_XL;
     }
 }
+function getAlternatingColorsPalette(quantity) {
+    if (quantity <= 6) {
+        return COLORS_SM;
+    }
+    else if (quantity <= 12) {
+        return ALTERNATING_COLORS_MD;
+    }
+    else if (quantity <= 24) {
+        return ALTERNATING_COLORS_LG;
+    }
+    else {
+        return ALTERNATING_COLORS_XL;
+    }
+}
 class ColorGenerator {
     preferredColors;
     currentColorIndex = 0;
@@ -1413,6 +1506,62 @@ class ColorGenerator {
             : getNthColor(this.currentColorIndex++, this.palette);
     }
 }
+class AlternatingColorGenerator extends ColorGenerator {
+    constructor(paletteSize, preferredColors = []) {
+        super(paletteSize, preferredColors);
+        this.palette = getAlternatingColorsPalette(paletteSize).filter((c) => !preferredColors.includes(c));
+    }
+}
+/**
+ * Returns a function that maps a value to a color using a color scale defined by the given
+ * color/threshold values pairs.
+ */
+function getColorScale(colorScalePoints) {
+    if (colorScalePoints.length < 2) {
+        throw new Error("Color scale must have at least 2 points");
+    }
+    const sortedColorScalePoints = [...colorScalePoints.sort((a, b) => a.value - b.value)];
+    const thresholds = [];
+    for (let i = 1; i < sortedColorScalePoints.length; i++) {
+        const minColor = colorToNumber(sortedColorScalePoints[i - 1].color);
+        const maxColor = colorToNumber(sortedColorScalePoints[i].color);
+        thresholds.push({
+            min: sortedColorScalePoints[i - 1].value,
+            max: sortedColorScalePoints[i].value,
+            minColor,
+            maxColor,
+            colorDiff: computeColorDiffUnits(sortedColorScalePoints[i - 1].value, sortedColorScalePoints[i].value, minColor, maxColor),
+        });
+    }
+    return (value) => {
+        if (value < thresholds[0].min) {
+            return colorNumberString(thresholds[0].minColor);
+        }
+        for (const threshold of thresholds) {
+            if (value >= threshold.min && value <= threshold.max) {
+                return colorNumberString(colorCell(value, threshold.min, threshold.minColor, threshold.colorDiff));
+            }
+        }
+        return colorNumberString(thresholds[thresholds.length - 1].maxColor);
+    };
+}
+function computeColorDiffUnits(minValue, maxValue, minColor, maxColor) {
+    const deltaValue = maxValue - minValue;
+    const deltaColorR = ((minColor >> 16) % 256) - ((maxColor >> 16) % 256);
+    const deltaColorG = ((minColor >> 8) % 256) - ((maxColor >> 8) % 256);
+    const deltaColorB = (minColor % 256) - (maxColor % 256);
+    const colorDiffUnitR = deltaColorR / deltaValue;
+    const colorDiffUnitG = deltaColorG / deltaValue;
+    const colorDiffUnitB = deltaColorB / deltaValue;
+    return [colorDiffUnitR, colorDiffUnitG, colorDiffUnitB];
+}
+function colorCell(value, minValue, minColor, colorDiffUnit) {
+    const [colorDiffUnitR, colorDiffUnitG, colorDiffUnitB] = colorDiffUnit;
+    const r = Math.round(((minColor >> 16) % 256) - colorDiffUnitR * (value - minValue));
+    const g = Math.round(((minColor >> 8) % 256) - colorDiffUnitG * (value - minValue));
+    const b = Math.round((minColor % 256) - colorDiffUnitB * (value - minValue));
+    return (r << 16) | (g << 8) | b;
+}
 
 //------------------------------------------------------------------------------
 // Coordinate
@@ -3284,6 +3433,7 @@ const invalidateEvaluationCommands = new Set([
 ]);
 const invalidateChartEvaluationCommands = new Set([
     "EVALUATE_CELLS",
+    "EVALUATE_CHARTS",
     "UPDATE_CELL",
     "UNHIDE_COLUMNS_ROWS",
     "HIDE_COLUMNS_ROWS",
@@ -3320,6 +3470,7 @@ const readonlyAllowedCommands = new Set([
     "RESIZE_SHEETVIEW",
     "SET_VIEWPORT_OFFSET",
     "EVALUATE_CELLS",
+    "EVALUATE_CHARTS",
     "SET_FORMULA_VISIBILITY",
     "UPDATE_FILTER",
 ]);
@@ -6524,7 +6675,7 @@ class BorderClipboardHandler extends AbstractCellClipboardHandler {
 const POSTFIX_UNARY_OPERATORS = ["%"];
 const OPERATORS = "+,-,*,/,:,=,<>,>=,>,<=,<,^,&".split(",").concat(POSTFIX_UNARY_OPERATORS);
 function tokenize(str, locale = DEFAULT_LOCALE) {
-    str = replaceSpecialSpaces(str);
+    str = replaceNewLines(str);
     const chars = new TokenizingChars(str);
     const result = [];
     while (!chars.isOver()) {
@@ -6671,12 +6822,12 @@ function tokenizeSpace(chars) {
     if (length) {
         return { type: "SPACE", value: NEWLINE.repeat(length) };
     }
-    while (chars.current === " ") {
-        length++;
-        chars.shift();
+    let spaces = "";
+    while (chars.current && chars.current.match(whiteSpaceRegexp)) {
+        spaces += chars.shift();
     }
-    if (length) {
-        return { type: "SPACE", value: " ".repeat(length) };
+    if (spaces) {
+        return { type: "SPACE", value: spaces };
     }
     return null;
 }
@@ -7535,6 +7686,16 @@ function getRunningTotalDomainKey(domain, fieldNameWithGranularity) {
     }
     return domainToString([...domain.slice(0, index), ...domain.slice(index + 1)]);
 }
+function sortPivotTree(tree, baseDomain, sortFn) {
+    const sortedTree = [...tree];
+    const domain = [...baseDomain];
+    sortedTree.sort((node1, node2) => sortFn([...domain, node1], [...domain, node2]));
+    for (const node of tree) {
+        const children = sortPivotTree(node.children, [...domain, node], sortFn);
+        node.children = children;
+    }
+    return sortedTree;
+}
 
 const pivotTimeAdapterRegistry = new Registry();
 function pivotTimeAdapter(granularity) {
@@ -8045,6 +8206,29 @@ function addIndentAndAlignToPivotHeader(pivot, domain, functionResult) {
         format: `${"    ".repeat(indent)}${format}* `,
     };
 }
+function isSortedColumnValid(sortedColumn, pivot) {
+    try {
+        if (!pivot.getMeasure(sortedColumn.measure)) {
+            return false;
+        }
+        const columns = pivot.definition.columns;
+        for (let i = 0; i < sortedColumn.domain.length; i++) {
+            if (columns[i].nameWithGranularity !== sortedColumn.domain[i].field) {
+                return false;
+            }
+            const possibleValues = pivot
+                .getPossibleFieldValues(columns[i])
+                .map((v) => v.value);
+            if (!possibleValues.includes(sortedColumn.domain[i].value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
 
 class CellClipboardHandler extends AbstractCellClipboardHandler {
     isCutAllowed(data) {
@@ -14653,7 +14837,7 @@ const SORT_TYPES = [
     CellValueType.boolean,
 ];
 function cellsSortingCriterion(sortingOrder) {
-    const inverse = sortingOrder === "ascending" ? 1 : -1;
+    const inverse = sortingOrder === "asc" ? 1 : -1;
     return (left, right) => {
         if (left.type === CellValueType.empty) {
             return right.type === CellValueType.empty ? 0 : 1;
@@ -14745,7 +14929,7 @@ function sortMatrix(matrix, locale, ...criteria) {
     const sortColumns = [];
     const nRows = matrix.length;
     for (let i = 0; i < criteria.length; i += 2) {
-        sortingOrders.push(toBoolean(toScalar(criteria[i + 1])?.value) ? "ascending" : "descending");
+        sortingOrders.push(toBoolean(toScalar(criteria[i + 1])?.value) ? "asc" : "desc");
         const sortColumn = criteria[i];
         if (isMatrix(sortColumn) && (sortColumn.length > 1 || sortColumn[0].length > 1)) {
             assert(() => sortColumn.length === 1 && sortColumn[0].length === nRows, _t("Wrong size for %s. Expected a range of size 1x%s. Got %sx%s.", `sort_column${i + 1}`, nRows, sortColumn.length, sortColumn[0].length));
@@ -14762,12 +14946,12 @@ function sortMatrix(matrix, locale, ...criteria) {
     if (sortColumns.length === 0) {
         for (let i = 0; i < matrix[0].length; i++) {
             sortColumns.push(matrix.map((row) => row[i].value));
-            sortingOrders.push("ascending");
+            sortingOrders.push("asc");
         }
     }
     const sortingCriteria = {
-        descending: cellsSortingCriterion("descending"),
-        ascending: cellsSortingCriterion("ascending"),
+        desc: cellsSortingCriterion("desc"),
+        asc: cellsSortingCriterion("asc"),
     };
     const indexes = range(0, matrix.length);
     indexes.sort((a, b) => {
@@ -20491,20 +20675,8 @@ class AbstractComposerStore extends SpreadsheetStore {
     replaceSelectedRange(zone) {
         const ref = this.getZoneReference(zone);
         const currentToken = this.tokenAtCursor;
-        let replaceStart = this.selectionStart;
-        if (currentToken?.type === "REFERENCE") {
-            replaceStart = currentToken.start;
-        }
-        else if (currentToken?.type === "RIGHT_PAREN") {
-            // match left parenthesis
-            const leftParenthesisIndex = this.currentTokens.findIndex((token) => token.type === "LEFT_PAREN" && token.parenthesesCode === currentToken.parenthesesCode);
-            const functionToken = this.currentTokens[leftParenthesisIndex - 1];
-            if (functionToken === undefined) {
-                return;
-            }
-            replaceStart = functionToken.start;
-        }
-        this.replaceText(ref, replaceStart, this.selectionEnd);
+        const start = currentToken?.type === "REFERENCE" ? currentToken.start : this.selectionStart;
+        this.replaceText(ref, start, this.selectionEnd);
     }
     /**
      * Replace the reference of the old zone by the new one.
@@ -20537,17 +20709,6 @@ class AbstractComposerStore extends SpreadsheetStore {
     getZoneReference(zone) {
         const inputSheetId = this.sheetId;
         const sheetId = this.getters.getActiveSheetId();
-        if (zone.top === zone.bottom && zone.left === zone.right) {
-            const position = { sheetId, col: zone.left, row: zone.top };
-            const pivotId = this.getters.getPivotIdFromPosition(position);
-            const pivotCell = this.getters.getPivotCellFromPosition(position);
-            const cell = this.getters.getCell(position);
-            if (pivotId && pivotCell.type !== "EMPTY" && !cell?.isFormula) {
-                const formulaPivotId = this.getters.getPivotFormulaId(pivotId);
-                const formula = createPivotFormula(formulaPivotId, pivotCell);
-                return localizeFormula(formula, this.getters.getLocale()).slice(1); // strip leading =
-            }
-        }
         const range = this.getters.getRangeFromZone(sheetId, zone);
         return this.getters.getSelectionRangeString(range, inputSheetId);
     }
@@ -20718,37 +20879,21 @@ class AbstractComposerStore extends SpreadsheetStore {
         const editionSheetId = this.sheetId;
         const rangeColor = (rangeString) => {
             const colorIndex = this.colorIndexByRange[rangeString];
-            return colors$1[colorIndex % colors$1.length];
+            return colors[colorIndex % colors.length];
         };
-        const highlights = [];
-        for (const range of this.getReferencedRanges()) {
+        return this.getReferencedRanges().map((range) => {
             const rangeString = this.getters.getRangeString(range, editionSheetId);
             const { numberOfRows, numberOfCols } = zoneToDimension(range.zone);
             const zone = numberOfRows * numberOfCols === 1
                 ? this.getters.expandZone(range.sheetId, range.zone)
                 : range.zone;
-            highlights.push({
+            return {
                 zone,
                 color: rangeColor(rangeString),
                 sheetId: range.sheetId,
                 interactive: true,
-            });
-        }
-        const activeSheetId = this.getters.getActiveSheetId();
-        const selectionZone = this.model.selection.getAnchor().zone;
-        const isSelectionHightlighted = highlights.find((highlight) => highlight.sheetId === activeSheetId && isEqual(highlight.zone, selectionZone));
-        if (this.editionMode === "selecting" && !isSelectionHightlighted) {
-            highlights.push({
-                zone: selectionZone,
-                color: "#445566",
-                sheetId: activeSheetId,
-                dashed: true,
-                interactive: false,
-                noFill: true,
-                thinLine: true,
-            });
-        }
-        return highlights;
+            };
+        });
     }
     /**
      * Return ranges currently referenced in the composer
@@ -20976,6 +21121,7 @@ function compileTokens(tokens) {
                 return error;
             },
             isBadExpression: true,
+            normalizedFormula: tokens.map((t) => t.value).join(""),
         };
     }
 }
@@ -21103,6 +21249,7 @@ function compileTokensOrThrow(tokens) {
         symbols,
         tokens,
         isBadExpression: false,
+        normalizedFormula: cacheKey,
     };
     return compiledFormula;
 }
@@ -21367,6 +21514,7 @@ autoCompleteProviders.add("pivot_ids", {
                 description: definition.name,
                 htmlContent: [{ value: str, color: tokenColors.NUMBER }],
                 fuzzySearchKey: str + definition.name,
+                alwaysExpanded: true,
             };
         })
             .filter(isDefined);
@@ -27760,6 +27908,19 @@ const ChartTerms = {
         ["GaugeLowerInflectionPointNaN" /* CommandResult.GaugeLowerInflectionPointNaN */]: _t("The lower inflection point value must be a number"),
         ["GaugeUpperInflectionPointNaN" /* CommandResult.GaugeUpperInflectionPointNaN */]: _t("The upper inflection point value must be a number"),
     },
+    GeoChart: {
+        ColorScales: {
+            blues: _t("Blues"),
+            cividis: _t("Cividis"),
+            greens: _t("Greens"),
+            greys: _t("Greys"),
+            oranges: _t("Oranges"),
+            purples: _t("Purples"),
+            rainbow: _t("Rainbow"),
+            reds: _t("Reds"),
+            viridis: _t("Viridis"),
+        },
+    },
 };
 const CustomCurrencyTerms = {
     Custom: _t("Custom"),
@@ -28163,6 +28324,26 @@ function getRadarChartData(definition, dataSets, labelRange, getters) {
         locale: getters.getLocale(),
     };
 }
+function getGeoChartData(definition, dataSets, labelRange, getters) {
+    const labelValues = getChartLabelValues(getters, dataSets, labelRange);
+    let labels = labelValues.formattedValues;
+    if (definition.dataSetsHaveTitle) {
+        labels.shift();
+    }
+    let dataSetsValues = getChartDatasetValues(getters, dataSets);
+    ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
+    const format = getChartDatasetFormat(getters, dataSets, "left") ||
+        getChartDatasetFormat(getters, dataSets, "right");
+    return {
+        dataSetsValues,
+        axisFormats: { y: format },
+        labels,
+        locale: getters.getLocale(),
+        availableRegions: getters.getGeoChartAvailableRegions(),
+        geoFeatureNameToId: getters.geoFeatureNameToId,
+        getGeoJsonFeatures: getters.getGeoJsonFeatures,
+    };
+}
 function getTrendDatasetForBarChart(config, data) {
     const filteredValues = [];
     const filteredLabels = [];
@@ -28715,6 +28896,43 @@ function getRadarChartDatasets(definition, args) {
     }
     return datasets;
 }
+function getGeoChartDatasets(definition, args) {
+    const { availableRegions, dataSetsValues, labels } = args;
+    const regionName = definition.region || availableRegions[0]?.id;
+    const features = regionName ? args.getGeoJsonFeatures(regionName) : undefined;
+    const dataset = {
+        outline: features,
+        showOutline: !!features,
+        data: [],
+    };
+    if (features && regionName) {
+        const labelsAndValues = {};
+        if (dataSetsValues[0]) {
+            for (let i = 0; i < dataSetsValues[0].data.length; i++) {
+                if (!labels[i] || dataSetsValues[0].data[i] === undefined) {
+                    continue;
+                }
+                const featureId = args.geoFeatureNameToId(regionName, labels[i]);
+                if (featureId) {
+                    labelsAndValues[featureId] = { value: dataSetsValues[0].data[i], label: labels[i] };
+                }
+            }
+        }
+        for (const feature of features) {
+            if (!feature.id) {
+                continue;
+            }
+            dataset.data.push({
+                feature: {
+                    ...feature,
+                    properties: { name: labelsAndValues[feature.id]?.label },
+                },
+                value: labelsAndValues[feature.id]?.value,
+            });
+        }
+    }
+    return [dataset];
+}
 function getTrendingLineDataSet(dataset, config, data) {
     const defaultBorderColor = colorToRGBA(dataset.backgroundColor);
     defaultBorderColor.a = 1;
@@ -29092,6 +29310,44 @@ function getRadarChartScales(definition, args) {
         },
     };
 }
+function getGeoChartScales(definition, args) {
+    const { locale, axisFormats, availableRegions } = args;
+    const geoLegendPosition = legendPositionToGeoLegendPosition(definition.legendPosition);
+    const region = definition.region
+        ? availableRegions.find((r) => r.id === definition.region)
+        : availableRegions[0];
+    const format = axisFormats?.y || axisFormats?.y1;
+    return {
+        projection: {
+            // projection: region?.defaultProjection,
+            projection: getGeoChartProjection(region?.defaultProjection || "mercator"),
+            axis: "x",
+        },
+        color: {
+            axis: "x",
+            display: definition.legendPosition !== "none",
+            border: { color: GRAY_300 },
+            grid: { color: GRAY_300 },
+            ticks: {
+                color: chartFontColor(definition.background),
+                callback: formatTickValue({ locale, format }),
+            },
+            legend: {
+                position: geoLegendPosition,
+                align: geoLegendPosition.includes("right") ? "left" : "right",
+                margin: getLegendMargin(definition),
+            },
+            interpolate: getRuntimeColorScale(definition),
+            missing: definition.missingValueColor || "#ffffff",
+        },
+    };
+}
+function getGeoChartProjection(projection) {
+    if (projection === "conicConformal") {
+        return window.ChartGeo.geoConicConformal().rotate([100, 0]); // Centered on the US
+    }
+    return projection;
+}
 function getChartAxisTitleRuntime(design) {
     if (design?.title?.text) {
         const { text, color, align, italic, bold } = design.title;
@@ -29155,6 +29411,44 @@ function getChartAxis(definition, position, type, options) {
         };
     }
 }
+function getRuntimeColorScale(definition) {
+    if (!definition.colorScale || typeof definition.colorScale === "string") {
+        return definition.colorScale || "oranges";
+    }
+    const scaleColors = [{ value: 0, color: definition.colorScale.minColor }];
+    if (definition.colorScale.midColor) {
+        scaleColors.push({ value: 0.5, color: definition.colorScale.midColor });
+    }
+    scaleColors.push({ value: 1, color: definition.colorScale.maxColor });
+    return getColorScale(scaleColors);
+}
+function getLegendMargin(definition) {
+    switch (definition.legendPosition) {
+        case "top":
+        case "right":
+            const hasTitle = !!definition.title.text;
+            const topMargin = hasTitle ? CHART_PADDING_TOP + 30 : CHART_PADDING_TOP;
+            return { top: topMargin, left: CHART_PADDING$1, right: CHART_PADDING$1 };
+        case "bottom":
+        case "left":
+        case "none":
+            return { left: CHART_PADDING$1, right: CHART_PADDING$1, bottom: CHART_PADDING_BOTTOM };
+    }
+}
+function legendPositionToGeoLegendPosition(position) {
+    switch (position) {
+        case "top":
+            return "top-left";
+        case "right":
+            return "top-right";
+        case "bottom":
+            return "bottom-right";
+        case "left":
+            return "bottom-left";
+        case "none":
+            return "bottom-left";
+    }
+}
 
 function getChartShowValues(definition, args) {
     const { axisFormats, locale } = args;
@@ -29314,6 +29608,25 @@ function getRadarChartTooltip(definition, args) {
         },
     };
 }
+function getGeoChartTooltip(definition, args) {
+    const { locale, axisFormats } = args;
+    const format = axisFormats?.y || axisFormats?.y1;
+    return {
+        filter: function (tooltipItem) {
+            return tooltipItem.raw.value !== undefined;
+        },
+        callbacks: {
+            label: function (tooltipItem) {
+                const rawItem = tooltipItem.raw;
+                const xLabel = rawItem.feature.properties.name;
+                const yLabel = rawItem.value;
+                const toolTipFormat = !format && Math.abs(yLabel) >= 1000 ? "#,##" : format;
+                const yLabelStr = formatValue(yLabel, { format: toolTipFormat, locale });
+                return xLabel ? `${xLabel}: ${yLabelStr}` : yLabelStr;
+            },
+        },
+    };
+}
 function calculatePercentage(dataset, dataIndex) {
     const numericData = dataset.filter((value) => typeof value === "number");
     const total = numericData.reduce((sum, value) => sum + value, 0);
@@ -29340,6 +29653,10 @@ var CHART_RUNTIME_HELPERS = /*#__PURE__*/Object.freeze({
   getComboChartDatasets: getComboChartDatasets,
   getComboChartLegend: getComboChartLegend,
   getData: getData,
+  getGeoChartData: getGeoChartData,
+  getGeoChartDatasets: getGeoChartDatasets,
+  getGeoChartScales: getGeoChartScales,
+  getGeoChartTooltip: getGeoChartTooltip,
   getLineChartData: getLineChartData,
   getLineChartDatasets: getLineChartDatasets,
   getLineChartLegend: getLineChartLegend,
@@ -29913,6 +30230,133 @@ function getSectionThresholdValue(threshold, minValue, maxValue) {
     return clip(value, minValue, maxValue);
 }
 
+class GeoChart extends AbstractChart {
+    dataSets;
+    labelRange;
+    background;
+    legendPosition;
+    type = "geo";
+    dataSetsHaveTitle;
+    dataSetDesign;
+    colorScale;
+    missingValueColor;
+    region;
+    constructor(definition, sheetId, getters) {
+        super(definition, sheetId, getters);
+        this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
+        this.labelRange = createValidRange(getters, sheetId, definition.labelRange);
+        this.background = definition.background;
+        this.legendPosition = definition.legendPosition;
+        this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
+        this.dataSetDesign = definition.dataSets;
+        this.colorScale = definition.colorScale;
+        this.missingValueColor = definition.missingValueColor;
+        this.region = definition.region;
+    }
+    static transformDefinition(definition, executed) {
+        return transformChartDefinitionWithDataSetsWithZone(definition, executed);
+    }
+    static validateChartDefinition(validator, definition) {
+        return validator.checkValidations(definition, checkDataset, checkLabelRange);
+    }
+    static getDefinitionFromContextCreation(context) {
+        return {
+            background: context.background,
+            dataSets: context.range ?? [],
+            dataSetsHaveTitle: context.dataSetsHaveTitle ?? false,
+            legendPosition: context.legendPosition ?? "top",
+            title: context.title || { text: "" },
+            type: "geo",
+            labelRange: context.auxiliaryRange || undefined,
+            aggregated: context.aggregated,
+        };
+    }
+    getContextCreation() {
+        const range = [];
+        for (const [i, dataSet] of this.dataSets.entries()) {
+            range.push({
+                ...this.dataSetDesign?.[i],
+                dataRange: this.getters.getRangeString(dataSet.dataRange, this.sheetId),
+            });
+        }
+        return {
+            ...this,
+            range,
+            auxiliaryRange: this.labelRange
+                ? this.getters.getRangeString(this.labelRange, this.sheetId)
+                : undefined,
+        };
+    }
+    copyForSheetId(sheetId) {
+        const dataSets = copyDataSetsWithNewSheetId(this.sheetId, sheetId, this.dataSets);
+        const labelRange = copyLabelRangeWithNewSheetId(this.sheetId, sheetId, this.labelRange);
+        const definition = this.getDefinitionWithSpecificDataSets(dataSets, labelRange, sheetId);
+        return new GeoChart(definition, sheetId, this.getters);
+    }
+    copyInSheetId(sheetId) {
+        const definition = this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange, sheetId);
+        return new GeoChart(definition, sheetId, this.getters);
+    }
+    getDefinition() {
+        return this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange);
+    }
+    getDefinitionWithSpecificDataSets(dataSets, labelRange, targetSheetId) {
+        const ranges = [];
+        for (const [i, dataSet] of dataSets.entries()) {
+            ranges.push({
+                ...this.dataSetDesign?.[i],
+                dataRange: this.getters.getRangeString(dataSet.dataRange, targetSheetId || this.sheetId),
+            });
+        }
+        return {
+            type: "geo",
+            dataSetsHaveTitle: dataSets.length ? Boolean(dataSets[0].labelCell) : false,
+            background: this.background,
+            dataSets: ranges,
+            legendPosition: this.legendPosition,
+            labelRange: labelRange
+                ? this.getters.getRangeString(labelRange, targetSheetId || this.sheetId)
+                : undefined,
+            title: this.title,
+            colorScale: this.colorScale,
+            missingValueColor: this.missingValueColor,
+            region: this.region,
+        };
+    }
+    getDefinitionForExcel() {
+        return undefined;
+    }
+    updateRanges(applyChange) {
+        const { dataSets, labelRange, isStale } = updateChartRangesWithDataSets(this.getters, applyChange, this.dataSets, this.labelRange);
+        if (!isStale) {
+            return this;
+        }
+        const definition = this.getDefinitionWithSpecificDataSets(dataSets, labelRange);
+        return new GeoChart(definition, this.sheetId, this.getters);
+    }
+}
+function createGeoChartRuntime(chart, getters) {
+    const definition = chart.getDefinition();
+    const chartData = getGeoChartData(definition, chart.dataSets, chart.labelRange, getters);
+    const config = {
+        type: "choropleth",
+        data: {
+            datasets: getGeoChartDatasets(definition, chartData),
+        },
+        options: {
+            ...CHART_COMMON_OPTIONS,
+            layout: getChartLayout(),
+            scales: getGeoChartScales(definition, chartData),
+            plugins: {
+                title: getChartTitle(definition),
+                tooltip: getGeoChartTooltip(definition, chartData),
+                legend: { display: false },
+            },
+        },
+    };
+    return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
+}
+
 class LineChart extends AbstractChart {
     dataSets;
     labelRange;
@@ -30906,6 +31350,15 @@ chartRegistry.add("radar", {
     getChartDefinitionFromContextCreation: RadarChart.getDefinitionFromContextCreation,
     sequence: 80,
 });
+chartRegistry.add("geo", {
+    match: (type) => type === "geo",
+    createChart: (definition, sheetId, getters) => new GeoChart(definition, sheetId, getters),
+    getChartRuntime: createGeoChartRuntime,
+    validateChartDefinition: GeoChart.validateChartDefinition,
+    transformDefinition: GeoChart.transformDefinition,
+    getChartDefinitionFromContextCreation: GeoChart.getDefinitionFromContextCreation,
+    sequence: 90,
+});
 const chartComponentRegistry = new Registry();
 chartComponentRegistry.add("line", ChartJsComponent);
 chartComponentRegistry.add("bar", ChartJsComponent);
@@ -30917,6 +31370,7 @@ chartComponentRegistry.add("scorecard", ScorecardChart);
 chartComponentRegistry.add("waterfall", ChartJsComponent);
 chartComponentRegistry.add("pyramid", ChartJsComponent);
 chartComponentRegistry.add("radar", ChartJsComponent);
+chartComponentRegistry.add("geo", ChartJsComponent);
 const chartCategories = {
     line: _t("Line"),
     column: _t("Column"),
@@ -31076,6 +31530,13 @@ chartSubtypeRegistry
     subtypeDefinition: { fillArea: true },
     category: "misc",
     preview: "o-spreadsheet-ChartPreview.FILLED_RADAR_CHART",
+})
+    .add("geo", {
+    displayName: _t("Geo Chart"),
+    chartSubtype: "geo",
+    chartType: "geo",
+    category: "misc",
+    preview: "o-spreadsheet-ChartPreview.GEO_CHART",
 });
 
 /**
@@ -31926,18 +32387,66 @@ const ErrorToolTipPopoverBuilder = {
     },
 };
 
-css /*SCSS*/ `
-  .o-filter-menu-value {
-    padding: 4px;
-    line-height: 20px;
-    height: 28px;
-    .o-filter-menu-value-checked {
-      width: 20px;
+const CHECK_SVG = /*xml*/ `
+<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'>
+  <path fill='none' stroke='#FFF' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='m6 10 3 3 6-6'/>
+</svg>
+`;
+const CHECKBOX_WIDTH = 14;
+css /* scss */ `
+  label.o-checkbox {
+    input {
+      appearance: none;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+      border-radius: 0;
+      width: ${CHECKBOX_WIDTH}px;
+      height: ${CHECKBOX_WIDTH}px;
+      vertical-align: top;
+      box-sizing: border-box;
+      outline: none;
+      border: 1px solid ${GRAY_300};
+      cursor: pointer;
+
+      &:hover {
+        border-color: ${ACTION_COLOR};
+      }
+
+      &:checked {
+        background: url("data:image/svg+xml,${encodeURIComponent(CHECK_SVG)}");
+        background-color: ${ACTION_COLOR};
+        border-color: ${ACTION_COLOR};
+      }
+
+      &:focus {
+        outline: none;
+        box-shadow: 0 0 0 0.25rem rgba(113, 75, 103, 0.25);
+        border-color: ${ACTION_COLOR};
+      }
     }
   }
 `;
+class Checkbox extends owl.Component {
+    static template = "o-spreadsheet.Checkbox";
+    static props = {
+        label: { type: String, optional: true },
+        value: { type: Boolean, optional: true },
+        className: { type: String, optional: true },
+        name: { type: String, optional: true },
+        title: { type: String, optional: true },
+        disabled: { type: Boolean, optional: true },
+        onChange: Function,
+    };
+    static defaultProps = { value: false };
+    onChange(ev) {
+        const value = ev.target.checked;
+        this.props.onChange(value);
+    }
+}
+
 class FilterMenuValueItem extends owl.Component {
     static template = "o-spreadsheet-FilterMenuValueItem";
+    static components = { Checkbox };
     static props = {
         value: String,
         isChecked: Boolean,
@@ -31975,8 +32484,6 @@ const CSS = css /* scss */ `
     .o-filter-menu-item {
       display: flex;
       box-sizing: border-box;
-      height: ${MENU_ITEM_HEIGHT}px;
-      padding: 4px 4px 4px 0px;
       cursor: pointer;
       user-select: none;
 
@@ -31985,14 +32492,6 @@ const CSS = css /* scss */ `
       }
     }
 
-    input {
-      box-sizing: border-box;
-      margin-bottom: 5px;
-      border: 1px solid #949494;
-      height: 24px;
-      padding-right: 28px;
-    }
-
     .o-search-icon {
       right: 5px;
       top: 3px;
@@ -32009,19 +32508,12 @@ const CSS = css /* scss */ `
       display: flex;
       flex-direction: row;
       margin-bottom: 4px;
-
-      .o-filter-menu-action-text {
-        cursor: pointer;
-        margin-right: 10px;
-        color: blue;
-        text-decoration: underline;
-      }
     }
 
     .o-filter-menu-list {
       flex: auto;
       overflow-y: auto;
-      border: 1px solid #949494;
+      border: 1px solid ${GRAY_300};
 
       .o-filter-menu-no-values {
         color: #949494;
@@ -34213,6 +34705,21 @@ const pivotProperties = {
     isReadonlyAllowed: true,
     icon: "o-spreadsheet-Icon.PIVOT",
 };
+const pivotSortingAsc = {
+    name: _t("Ascending"),
+    execute: (env) => sortPivot(env, "asc"),
+    isActive: (env) => isPivotSortMenuItemActive(env, "asc"),
+};
+const pivotSortingDesc = {
+    name: _t("Descending"),
+    execute: (env) => sortPivot(env, "desc"),
+    isActive: (env) => isPivotSortMenuItemActive(env, "desc"),
+};
+const noPivotSorting = {
+    name: _t("No sorting"),
+    execute: (env) => sortPivot(env, "none"),
+    isActive: (env) => isPivotSortMenuItemActive(env, "none"),
+};
 const FIX_FORMULAS = {
     name: _t("Convert to individual formulas"),
     execute(env) {
@@ -34249,6 +34756,66 @@ const FIX_FORMULAS = {
     },
     icon: "o-spreadsheet-Icon.PIVOT",
 };
+function canSortPivot(env) {
+    const position = env.model.getters.getActivePosition();
+    const pivotId = env.model.getters.getPivotIdFromPosition(position);
+    if (!pivotId ||
+        !env.model.getters.isExistingPivot(pivotId) ||
+        !env.model.getters.isSpillPivotFormula(position)) {
+        return false;
+    }
+    const pivot = env.model.getters.getPivot(pivotId);
+    if (!pivot.isValid()) {
+        return false;
+    }
+    const pivotCell = env.model.getters.getPivotCellFromPosition(position);
+    return pivotCell.type === "VALUE" || pivotCell.type === "MEASURE_HEADER";
+}
+function sortPivot(env, order) {
+    const position = env.model.getters.getActivePosition();
+    const pivotId = env.model.getters.getPivotIdFromPosition(position);
+    const pivotCell = env.model.getters.getPivotCellFromPosition(position);
+    if (pivotCell.type === "EMPTY" || pivotCell.type === "HEADER" || !pivotId) {
+        return;
+    }
+    if (order === "none") {
+        env.model.dispatch("UPDATE_PIVOT", {
+            pivotId: pivotId,
+            pivot: {
+                ...env.model.getters.getPivotCoreDefinition(pivotId),
+                sortedColumn: undefined,
+            },
+        });
+        return;
+    }
+    const pivot = env.model.getters.getPivot(pivotId);
+    const colDomain = domainToColRowDomain(pivot, pivotCell.domain).colDomain;
+    env.model.dispatch("UPDATE_PIVOT", {
+        pivotId: pivotId,
+        pivot: {
+            ...env.model.getters.getPivotCoreDefinition(pivotId),
+            sortedColumn: { domain: colDomain, order, measure: pivotCell.measure },
+        },
+    });
+}
+function isPivotSortMenuItemActive(env, order) {
+    const position = env.model.getters.getActivePosition();
+    const pivotId = env.model.getters.getPivotIdFromPosition(position);
+    const pivotCell = env.model.getters.getPivotCellFromPosition(position);
+    if (pivotCell.type === "EMPTY" || pivotCell.type === "HEADER" || !pivotId) {
+        return false;
+    }
+    const pivot = env.model.getters.getPivot(pivotId);
+    const colDomain = domainToColRowDomain(pivot, pivotCell.domain).colDomain;
+    const sortedColumn = pivot.definition.sortedColumn;
+    if (order === "none") {
+        return !sortedColumn;
+    }
+    if (!sortedColumn || sortedColumn.order !== order) {
+        return false;
+    }
+    return sortedColumn.measure === pivotCell.measure && deepEquals(sortedColumn.domain, colDomain);
+}
 
 //------------------------------------------------------------------------------
 // Context Menu Registry
@@ -34347,14 +34914,33 @@ cellMenuRegistry
     name: INSERT_LINK_NAME,
     sequence: 150,
     separator: true,
+})
+    .add("pivot_sorting", {
+    name: _t("Sort pivot"),
+    sequence: 155,
+    icon: "o-spreadsheet-Icon.SORT_RANGE",
+    isVisible: canSortPivot,
 })
     .add("pivot_fix_formulas", {
     ...FIX_FORMULAS,
-    sequence: 155,
+    sequence: 160,
 })
     .add("pivot_properties", {
     ...pivotProperties,
     sequence: 170,
+    separator: true,
+})
+    .addChild("pivot_sorting_asc", ["pivot_sorting"], {
+    ...pivotSortingAsc,
+    sequence: 10,
+})
+    .addChild("pivot_sorting_desc", ["pivot_sorting"], {
+    ...pivotSortingDesc,
+    sequence: 20,
+})
+    .addChild("pivot_sorting_none", ["pivot_sorting"], {
+    ...noPivotSorting,
+    sequence: 30,
 });
 
 const sortRange = {
@@ -34367,7 +34953,7 @@ const sortAscending = {
     execute: (env) => {
         const { anchor, zones } = env.model.getters.getSelection();
         const sheetId = env.model.getters.getActiveSheetId();
-        interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "ascending");
+        interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "asc");
     },
     icon: "o-spreadsheet-Icon.SORT_ASCENDING",
 };
@@ -34395,7 +34981,7 @@ const sortDescending = {
     execute: (env) => {
         const { anchor, zones } = env.model.getters.getSelection();
         const sheetId = env.model.getters.getActiveSheetId();
-        interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "descending");
+        interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "desc");
     },
     icon: "o-spreadsheet-Icon.SORT_DESCENDING",
 };
@@ -34878,6 +35464,227 @@ function interactiveFreezeColumnsRows(env, dimension, base) {
     }
 }
 
+class PositionMap {
+    map = {};
+    constructor(entries = []) {
+        for (const [position, value] of entries) {
+            this.set(position, value);
+        }
+    }
+    set({ sheetId, col, row }, value) {
+        const map = this.map;
+        if (!map[sheetId]) {
+            map[sheetId] = {};
+        }
+        if (!map[sheetId][col]) {
+            map[sheetId][col] = {};
+        }
+        map[sheetId][col][row] = value;
+    }
+    get({ sheetId, col, row }) {
+        return this.map[sheetId]?.[col]?.[row];
+    }
+    getSheet(sheetId) {
+        return this.map[sheetId];
+    }
+    has({ sheetId, col, row }) {
+        return this.map[sheetId]?.[col]?.[row] !== undefined;
+    }
+    delete({ sheetId, col, row }) {
+        delete this.map[sheetId]?.[col]?.[row];
+    }
+    keys() {
+        const map = this.map;
+        const keys = [];
+        for (const sheetId in map) {
+            for (const col in map[sheetId]) {
+                for (const row in map[sheetId][col]) {
+                    keys.push({ sheetId, col: parseInt(col), row: parseInt(row) });
+                }
+            }
+        }
+        return keys;
+    }
+    keysForSheet(sheetId) {
+        const map = this.map[sheetId];
+        if (!map) {
+            return [];
+        }
+        const keys = [];
+        for (const col in map) {
+            for (const row in map[col]) {
+                keys.push({ sheetId, col: parseInt(col), row: parseInt(row) });
+            }
+        }
+        return keys;
+    }
+    *entries() {
+        const map = this.map;
+        for (const position of this.keys()) {
+            const { sheetId, col, row } = position;
+            yield [position, map[sheetId][col][row]];
+        }
+    }
+}
+
+class FormulaFingerprintStore extends SpreadsheetStore {
+    mutators = ["enable", "disable"];
+    isInvalidated = false;
+    fingerprintColors = {
+        [DATA_FINGERPRINT]: "#D9D9D9",
+    };
+    isEnabled = false;
+    colors = new PositionMap();
+    handle(cmd) {
+        if (isCoreCommand(cmd) && this.isEnabled) {
+            this.isInvalidated = true;
+        }
+        switch (cmd.type) {
+            case "UNDO":
+            case "REDO":
+            case "ACTIVATE_SHEET":
+                if (this.isEnabled) {
+                    this.isInvalidated = true;
+                }
+                break;
+        }
+    }
+    finalize() {
+        if (this.isInvalidated) {
+            this.isInvalidated = false;
+            this.computeFingerprints();
+        }
+    }
+    enable() {
+        this.isEnabled = true;
+        this.computeFingerprints();
+    }
+    disable() {
+        this.isEnabled = false;
+        this.colors = new PositionMap();
+    }
+    computeFingerprints() {
+        this.colors = new PositionMap();
+        const fingerprints = new PositionMap();
+        const allFingerprints = new Set();
+        const activeSheetId = this.getters.getActiveSheetId();
+        const cells = this.getters.getCells(activeSheetId);
+        for (const cellId in cells) {
+            const fingerprint = this.computeFingerprint(cells[cellId]);
+            if (!fingerprint) {
+                continue;
+            }
+            allFingerprints.add(fingerprint);
+            const position = this.getters.getCellPosition(cellId);
+            fingerprints.set(position, fingerprint);
+        }
+        this.assignColors(allFingerprints);
+        for (const [position, fingerprint] of fingerprints.entries()) {
+            const color = this.fingerprintColors[fingerprint];
+            this.colors.set(position, color);
+            this.colorSpreadZone(position, color);
+        }
+    }
+    colorSpreadZone(position, fingerprintColor) {
+        const spreadZone = this.getters.getSpreadZone(position);
+        if (!spreadZone) {
+            return;
+        }
+        const sheetId = position.sheetId;
+        for (let row = spreadZone.top; row <= spreadZone.bottom; row++) {
+            for (let col = spreadZone.left; col <= spreadZone.right; col++) {
+                const spreadPosition = { sheetId, col, row };
+                this.colors.set(spreadPosition, fingerprintColor);
+            }
+        }
+    }
+    assignColors(fingerprints) {
+        const colors = new AlternatingColorGenerator(fingerprints.size);
+        Object.keys(this.fingerprintColors).forEach(() => colors.next());
+        for (const fingerprint of fingerprints) {
+            if (!this.fingerprintColors[fingerprint]) {
+                this.fingerprintColors[fingerprint] = setColorAlpha(colors.next(), 0.8);
+            }
+        }
+    }
+    computeFingerprint(cell) {
+        const position = this.getters.getCellPosition(cell.id);
+        if (cell.isFormula) {
+            return this.computeFormulaFingerprint(position, cell);
+        }
+        else {
+            return this.getLiteralFingerprint(position);
+        }
+    }
+    computeFormulaFingerprint(position, cell) {
+        const dependencies = cell.compiledFormula.dependencies;
+        const colCellOffset = position.col;
+        const rowCellOffset = position.row;
+        const positionSheetIndex = this.getters.getSheetIds().indexOf(position.sheetId);
+        // As an optimization, we do not build each reference vector individually
+        // to sum them up, but instead we directly add each component to the resulting
+        // vector. This is equivalent to summing up all reference vectors.
+        const fingerprintVector = {
+            dx: 0,
+            dy: 0,
+            dSheet: 0,
+        };
+        for (const range of dependencies) {
+            const zone = range.zone;
+            const [left, right] = range.parts;
+            const rangeSheetIndex = this.getters.getSheetIds().indexOf(range.sheetId);
+            fingerprintVector.dSheet = rangeSheetIndex - positionSheetIndex;
+            // in relative mode, we offset the col and row by the cell's position
+            // in absolute mode, we offset the col and row relative to the sheet
+            const isLeftUnbounded = range.isFullRow && !range.unboundedZone.hasHeader;
+            const isTopUnbounded = range.isFullCol && !range.unboundedZone.hasHeader;
+            const leftOffset = isLeftUnbounded || left?.colFixed ? 0 : colCellOffset;
+            const topOffset = isTopUnbounded || left?.rowFixed ? 0 : rowCellOffset;
+            const isRightFixed = (!right && left?.colFixed) || right?.colFixed;
+            const isBottomFixed = (!right && left.rowFixed) || right?.rowFixed;
+            const isRightUnbounded = range.unboundedZone.right === undefined;
+            const isBottomUnbounded = range.unboundedZone.bottom === undefined;
+            const rightOffset = isRightUnbounded || isRightFixed ? 0 : colCellOffset;
+            const bottomOffset = isBottomUnbounded || isBottomFixed ? 0 : rowCellOffset;
+            const referenceZone = reorderZone({
+                top: zone.top - topOffset,
+                left: zone.left - leftOffset,
+                right: zone.right - rightOffset,
+                bottom: zone.bottom - bottomOffset,
+            });
+            for (let dy = referenceZone.top; dy <= referenceZone.bottom; dy++) {
+                for (let dx = referenceZone.left; dx <= referenceZone.right; dx++) {
+                    fingerprintVector.dx += dx;
+                    fingerprintVector.dy += dy;
+                }
+            }
+        }
+        // removes the index placeholders from the normalized formula
+        // =|N0|+|N1|+|N0| -> =|N|+|N|+|N|
+        const normalizedFormula = cell.compiledFormula.normalizedFormula.replace(/(|\w)(\d)(|)/g, "$1$3");
+        return hash(fingerprintVector) + normalizedFormula;
+    }
+    getLiteralFingerprint(position) {
+        const evaluatedCell = this.getters.getEvaluatedCell(position);
+        switch (evaluatedCell.type) {
+            case CellValueType.number:
+            case CellValueType.boolean:
+                return DATA_FINGERPRINT;
+            case CellValueType.text:
+            case CellValueType.empty:
+            case CellValueType.error:
+                return undefined;
+        }
+    }
+}
+function hash(vector) {
+    return Object.entries(vector)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([_, value]) => value)
+        .join(",");
+}
+const DATA_FINGERPRINT = "DATA_FINGERPRINT";
+
 const hideCols = {
     name: HIDE_COLUMNS_NAME,
     execute: (env) => {
@@ -35049,6 +35856,19 @@ const viewGridlines = {
         return env.model.getters.getGridLinesVisibility(sheetId);
     },
 };
+const irregularityMap = {
+    name: _t("Irregularity map"),
+    execute: (env) => {
+        const fingerprintStore = env.getStore(FormulaFingerprintStore);
+        if (fingerprintStore.isEnabled) {
+            fingerprintStore.disable();
+        }
+        else {
+            fingerprintStore.enable();
+        }
+    },
+    icon: "o-spreadsheet-Icon.IRREGULARITY_MAP",
+};
 const viewFormulas = {
     name: _t("Formulas"),
     isActive: (env) => env.model.getters.shouldShowFormulas(),
@@ -35666,6 +36486,11 @@ topbarMenuRegistry
     .addChild("view_formulas", ["view", "show"], {
     ...viewFormulas,
     sequence: 10,
+})
+    .addChild("view_irregularity_map", ["view"], {
+    ...irregularityMap,
+    sequence: 40,
+    separator: true,
 })
     // ---------------------------------------------------------------------
     // INSERT MENU ITEMS
@@ -35968,62 +36793,6 @@ class OTRegistry extends Registry {
 }
 const otRegistry = new OTRegistry();
 
-const CHECK_SVG = /*xml*/ `
-<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'>
-  <path fill='none' stroke='#FFF' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='m6 10 3 3 6-6'/>
-</svg>
-`;
-const CHECKBOX_WIDTH = 14;
-css /* scss */ `
-  label.o-checkbox {
-    input {
-      appearance: none;
-      -webkit-appearance: none;
-      -moz-appearance: none;
-      border-radius: 0;
-      width: ${CHECKBOX_WIDTH}px;
-      height: ${CHECKBOX_WIDTH}px;
-      vertical-align: top;
-      box-sizing: border-box;
-      outline: none;
-      border: 1px solid ${GRAY_300};
-
-      &:hover {
-        border-color: ${ACTION_COLOR};
-      }
-
-      &:checked {
-        background: url("data:image/svg+xml,${encodeURIComponent(CHECK_SVG)}");
-        background-color: ${ACTION_COLOR};
-        border-color: ${ACTION_COLOR};
-      }
-
-      &:focus {
-        outline: none;
-        box-shadow: 0 0 0 0.25rem rgba(113, 75, 103, 0.25);
-        border-color: ${ACTION_COLOR};
-      }
-    }
-  }
-`;
-class Checkbox extends owl.Component {
-    static template = "o-spreadsheet.Checkbox";
-    static props = {
-        label: { type: String, optional: true },
-        value: { type: Boolean, optional: true },
-        className: { type: String, optional: true },
-        name: { type: String, optional: true },
-        title: { type: String, optional: true },
-        disabled: { type: Boolean, optional: true },
-        onChange: Function,
-    };
-    static defaultProps = { value: false };
-    onChange(ev) {
-        const value = ev.target.checked;
-        this.props.onChange(value);
-    }
-}
-
 class Section extends owl.Component {
     static template = "o_spreadsheet.Section";
     static props = {
@@ -38263,6 +39032,104 @@ class GaugeChartDesignPanel extends owl.Component {
     }
 }
 
+class GeoChartRegionSelectSection extends owl.Component {
+    static template = "o-spreadsheet-GeoChartRegionSelectSection";
+    static components = { Section };
+    static props = {
+        figureId: String,
+        definition: Object,
+        updateChart: Function,
+    };
+    updateSelectedRegion(ev) {
+        const value = ev.target.value;
+        this.props.updateChart(this.props.figureId, { region: value });
+    }
+    get availableRegions() {
+        return this.env.model.getters.getGeoChartAvailableRegions();
+    }
+    get selectedRegion() {
+        return this.props.definition.region || this.availableRegions[0]?.id;
+    }
+}
+
+class GeoChartConfigPanel extends GenericChartConfigPanel {
+    static template = "o-spreadsheet-GeoChartConfigPanel";
+    static components = { ...GenericChartConfigPanel.components, GeoChartRegionSelectSection };
+    get dataRanges() {
+        return this.getDataSeriesRanges().slice(0, 1);
+    }
+    onDataSeriesConfirmed() {
+        this.dataSeriesRanges = spreadRange(this.env.model.getters, this.dataSeriesRanges).slice(0, 1);
+        this.state.datasetDispatchResult = this.props.updateChart(this.props.figureId, {
+            dataSets: this.dataSeriesRanges,
+        });
+    }
+    getLabelRangeOptions() {
+        return [
+            {
+                name: "dataSetsHaveTitle",
+                label: this.dataSetsHaveTitleLabel,
+                value: this.props.definition.dataSetsHaveTitle,
+                onChange: this.onUpdateDataSetsHaveTitle.bind(this),
+            },
+        ];
+    }
+}
+
+const DEFAULT_CUSTOM_COLOR_SCALE = {
+    minColor: "#FFF5EB",
+    midColor: "#FD8D3C",
+    maxColor: "#7F2704",
+};
+class GeoChartDesignPanel extends ChartWithAxisDesignPanel {
+    static template = "o-spreadsheet-GeoChartDesignPanel";
+    static components = { ...ChartWithAxisDesignPanel.components, RoundColorPicker };
+    colorScalesChoices = ChartTerms.GeoChart.ColorScales;
+    updateColorScaleType(ev) {
+        const value = ev.target.value;
+        value === "custom"
+            ? this.updateColorScale(DEFAULT_CUSTOM_COLOR_SCALE)
+            : this.updateColorScale(value);
+    }
+    updateColorScale(colorScale) {
+        this.props.updateChart(this.props.figureId, { colorScale });
+    }
+    updateMissingValueColor(color) {
+        this.props.updateChart(this.props.figureId, { missingValueColor: color });
+    }
+    updateLegendPosition(ev) {
+        const value = ev.target.value;
+        this.props.updateChart(this.props.figureId, { legendPosition: value });
+    }
+    get selectedColorScale() {
+        return typeof this.props.definition.colorScale === "object"
+            ? "custom"
+            : this.props.definition.colorScale || "oranges";
+    }
+    get selectedMissingValueColor() {
+        return this.props.definition.missingValueColor || "#ffffff";
+    }
+    get customColorScale() {
+        if (typeof this.props.definition.colorScale === "object") {
+            return this.props.definition.colorScale;
+        }
+        return undefined;
+    }
+    getCustomColorScaleColor(color) {
+        return this.customColorScale?.[color] ?? "";
+    }
+    setCustomColorScaleColor(colorType, color) {
+        if (!color && colorType !== "midColor") {
+            color = "#fff";
+        }
+        const customColorScale = this.customColorScale;
+        if (!customColorScale) {
+            return;
+        }
+        this.updateColorScale({ ...customColorScale, [colorType]: color });
+    }
+}
+
 class LineConfigPanel extends GenericChartConfigPanel {
     static template = "o-spreadsheet-LineConfigPanel";
     get canTreatLabelsAsText() {
@@ -38576,6 +39443,10 @@ chartSidePanelComponentRegistry
     .add("radar", {
     configuration: GenericChartConfigPanel,
     design: RadarChartDesignPanel,
+})
+    .add("geo", {
+    configuration: GeoChartConfigPanel,
+    design: GeoChartDesignPanel,
 });
 
 css /* scss */ `
@@ -39939,7 +40810,7 @@ css /* scss */ `
       border-color: ${GRAY_300};
 
       &.active {
-        border-color: ${SELECTION_BORDER_COLOR};
+        border-color: ${ACTION_COLOR};
       }
 
       &.o-invalid {
@@ -40897,7 +41768,7 @@ class ConditionalFormattingEditor extends owl.Component {
         }
         const point = this.state.rules.colorScale[target];
         if (point) {
-            point.color = Number.parseInt(color.slice(1), 16);
+            point.color = colorToNumber(color);
         }
         this.updateConditionalFormat({ rule: this.state.rules.colorScale });
         this.closeMenus();
@@ -41042,6 +41913,9 @@ class ConditionalFormattingEditor extends owl.Component {
         return [this.state.rules.dataBar.rangeValues || ""];
     }
     updateDataBarColor(color) {
+        if (!isColorValid(color)) {
+            return;
+        }
         this.state.rules.dataBar.color = Number.parseInt(color.slice(1), 16);
         this.updateConditionalFormat({ rule: this.state.rules.dataBar });
     }
@@ -43645,6 +44519,64 @@ class PivotMeasureEditor extends owl.Component {
     }
 }
 
+css /* scss */ `
+  .o-pivot-sort {
+    .o-sort-card {
+      width: fit-content;
+      background-color: ${GRAY_100};
+      border: 1px solid ${GRAY_300};
+
+      .o-sort-value {
+        color: ${PRIMARY_BUTTON_BG};
+      }
+    }
+  }
+`;
+class PivotSortSection extends owl.Component {
+    static template = "o-spreadsheet-PivotSortSection";
+    static components = {
+        Section,
+    };
+    static props = {
+        definition: Object,
+        pivotId: String,
+    };
+    get hasValidSort() {
+        const pivot = this.env.model.getters.getPivot(this.props.pivotId);
+        return (!!this.props.definition.sortedColumn &&
+            isSortedColumnValid(this.props.definition.sortedColumn, pivot));
+    }
+    get sortDescription() {
+        const sortOrder = this.props.definition.sortedColumn?.order === "asc" ? _t("ascending") : _t("descending");
+        return _t("Sorted on column (%(ascOrDesc)s):", {
+            ascOrDesc: sortOrder,
+        });
+    }
+    get sortValuesAndFields() {
+        const sortedColumn = this.props.definition.sortedColumn;
+        if (!sortedColumn) {
+            return [];
+        }
+        const pivot = this.env.model.getters.getPivot(this.props.pivotId);
+        const locale = this.env.model.getters.getLocale();
+        const currentDomain = [];
+        const sortValues = [];
+        for (const domainItem of sortedColumn.domain) {
+            currentDomain.push(domainItem);
+            const { value, format } = pivot.getPivotHeaderValueAndFormat(currentDomain);
+            const label = formatValue(value, { format, locale });
+            const field = pivot.definition.getDimension(domainItem.field);
+            sortValues.push({ field: getFieldDisplayName(field), value: label });
+        }
+        if (sortedColumn.domain.length === 0) {
+            sortValues.push({ value: _t("Total") });
+        }
+        const measureLabel = pivot.getMeasure(sortedColumn.measure).displayName;
+        sortValues.push({ value: measureLabel, field: _t("Measure") });
+        return sortValues;
+    }
+}
+
 css /* scss */ `
   .add-calculated-measure {
     cursor: pointer;
@@ -43658,6 +44590,7 @@ class PivotLayoutConfigurator extends owl.Component {
         PivotDimensionOrder,
         PivotDimensionGranularity,
         PivotMeasureEditor,
+        PivotSortSection,
     };
     static props = {
         definition: Object,
@@ -43814,9 +44747,13 @@ class PivotLayoutConfigurator extends owl.Component {
     }
     updateMeasure(measure, newMeasure) {
         const { measures } = this.props.definition;
-        this.props.onDimensionsUpdated({
+        const update = {
             measures: measures.map((m) => (m.id === measure.id ? newMeasure : m)),
-        });
+        };
+        if (this.props.definition.sortedColumn?.measure === measure.id) {
+            update.sortedColumn = { ...this.props.definition.sortedColumn, measure: newMeasure.id };
+        }
+        this.props.onDimensionsUpdated(update);
     }
     getMeasureId(fieldName, aggregator) {
         const baseId = fieldName + (aggregator ? `:${aggregator}` : "");
@@ -43972,10 +44909,12 @@ class PivotRuntimeDefinition {
     measures;
     columns;
     rows;
+    sortedColumn;
     constructor(definition, fields) {
         this.measures = definition.measures.map((measure) => createMeasure(fields, measure));
         this.columns = definition.columns.map((dimension) => createPivotDimension(fields, dimension));
         this.rows = definition.rows.map((dimension) => createPivotDimension(fields, dimension));
+        this.sortedColumn = definition.sortedColumn;
     }
     getDimension(nameWithGranularity) {
         const dimension = this.columns.find((d) => d.nameWithGranularity === nameWithGranularity) ||
@@ -44129,6 +45068,7 @@ class SpreadsheetPivotTable {
     pivotCells = {};
     rowTree;
     colTree;
+    isSorted = false;
     constructor(columns, rows, measures, fieldsType) {
         this.columns = columns.map((row) => {
             // offset in the pivot table
@@ -44302,6 +45242,7 @@ class SpreadsheetPivotTable {
                 value,
                 field: row.fields[rowDepth],
                 children: [],
+                type: this.fieldsType[fieldName] || "char",
                 width: 0, // not used
             };
             treesAtDepth[depth].push(node);
@@ -44324,6 +45265,7 @@ class SpreadsheetPivotTable {
                     field: leaf.fields[depth],
                     children: [],
                     width: leaf.width,
+                    type: this.fieldsType[fieldName] || "char",
                 };
                 if (treesAtDepth[depth]?.at(-1)?.value !== value) {
                     treesAtDepth[depth + 1] = [];
@@ -44342,6 +45284,35 @@ class SpreadsheetPivotTable {
             fieldsType: this.fieldsType,
         };
     }
+    sort(measure, sortedColumn, getValue) {
+        if (this.isSorted) {
+            return;
+        }
+        const getSortValue = (measure, domain) => {
+            const rawValue = getValue(measure, domain).value;
+            return typeof rawValue === "number" ? rawValue : -Infinity;
+        };
+        const sortColDomain = sortedColumn.domain;
+        const sortFn = (rowDomain1, rowDomain2) => {
+            const value1 = getSortValue(measure, [...rowDomain1, ...sortColDomain]);
+            const value2 = getSortValue(measure, [...rowDomain2, ...sortColDomain]);
+            return sortedColumn.order === "asc" ? value1 - value2 : value2 - value1;
+        };
+        const sortedRowTree = sortPivotTree(this.rowTree(), [], sortFn);
+        this.rowTree = lazy(sortedRowTree);
+        this.rows = [...this.rowTreeToRows(sortedRowTree), this.rows[this.rows.length - 1]];
+        this.isSorted = true;
+    }
+    rowTreeToRows(tree, parentRow) {
+        return tree.flatMap((node) => {
+            const row = {
+                indent: parentRow ? parentRow.indent + 1 : 0,
+                fields: [...(parentRow?.fields || []), node.field],
+                values: [...(parentRow?.values || []), node.value],
+            };
+            return [row, ...this.rowTreeToRows(node.children, row)];
+        });
+    }
 }
 const EMPTY_PIVOT_CELL = { type: "EMPTY" };
 
@@ -44419,6 +45390,7 @@ function dataEntriesToColumnsTree(dataEntries, columns, index) {
             value: groups[key]?.[0]?.[column.nameWithGranularity]?.value ?? null,
             field: colName,
             children: dataEntriesToColumnsTree(groups[key] || [], columns, index + 1),
+            type: column.type,
             width: 0,
         };
     });
@@ -45284,6 +46256,7 @@ class PivotSidePanelStore extends SpreadsheetStore {
                 format: measure.format,
                 display: measure.display,
             })),
+            sortedColumn: this.shouldKeepSortedColumn(definition) ? definition.sortedColumn : undefined,
         };
         if (!this.draft && deepEquals(coreDefinition, cleanedDefinition)) {
             return;
@@ -45342,6 +46315,19 @@ class PivotSidePanelStore extends SpreadsheetStore {
         }
         return granularitiesPerFields;
     }
+    /**
+     * Check if we want to keep the sorted column when updating the pivot definition. We should remove it if either
+     * the measure is not in the new definition or the columns have changed.
+     */
+    shouldKeepSortedColumn(newDefinition) {
+        const { sortedColumn } = newDefinition;
+        if (!sortedColumn) {
+            return true;
+        }
+        const oldDefinition = this.getters.getPivotCoreDefinition(this.pivotId);
+        return (newDefinition.measures.find((measure) => measure.id === sortedColumn.measure) &&
+            deepEquals(oldDefinition.columns, newDefinition.columns));
+    }
 }
 
 class PivotSpreadsheetSidePanel extends owl.Component {
@@ -46443,6 +47429,7 @@ css /* scss */ `
     }
   }
 `;
+const DEFAULT_TABLE_STYLE_COLOR = "#3C78D8";
 class TableStyleEditorPanel extends owl.Component {
     static template = "o-spreadsheet-TableStyleEditorPanel";
     static components = { Section, RoundColorPicker, TableStylePreview };
@@ -46461,7 +47448,7 @@ class TableStyleEditorPanel extends owl.Component {
             : null;
         return {
             pickerOpened: false,
-            primaryColor: editedStyle?.primaryColor || "#3C78D8",
+            primaryColor: editedStyle?.primaryColor || DEFAULT_TABLE_STYLE_COLOR,
             selectedTemplateName: editedStyle?.templateName || "lightColoredText",
             styleName: editedStyle?.displayName || this.env.model.getters.getNewCustomTableStyleName(),
         };
@@ -46470,7 +47457,7 @@ class TableStyleEditorPanel extends owl.Component {
         this.state.pickerOpened = !this.state.pickerOpened;
     }
     onColorPicked(color) {
-        this.state.primaryColor = color;
+        this.state.primaryColor = isColorValid(color) ? color : DEFAULT_TABLE_STYLE_COLOR;
         this.state.pickerOpened = false;
     }
     onTemplatePicked(templateName) {
@@ -48086,6 +49073,7 @@ class FiguresContainer extends owl.Component {
         draggedFigure: undefined,
         horizontalSnap: undefined,
         verticalSnap: undefined,
+        cancelDnd: undefined,
     });
     setup() {
         owl.onMounted(() => {
@@ -48098,12 +49086,28 @@ class FiguresContainer extends owl.Component {
             // new rendering
             this.render();
         });
+        owl.onWillUpdateProps(() => {
+            const sheetId = this.env.model.getters.getActiveSheetId();
+            const draggedFigureId = this.dnd.draggedFigure?.id;
+            if (draggedFigureId && !this.env.model.getters.getFigure(sheetId, draggedFigureId)) {
+                if (this.dnd.cancelDnd) {
+                    this.dnd.cancelDnd();
+                }
+                this.dnd.draggedFigure = undefined;
+                this.dnd.horizontalSnap = undefined;
+                this.dnd.verticalSnap = undefined;
+                this.dnd.cancelDnd = undefined;
+            }
+        });
     }
     getVisibleFigures() {
         const visibleFigures = this.env.model.getters.getVisibleFigures();
         if (this.dnd.draggedFigure &&
             !visibleFigures.some((figure) => figure.id === this.dnd.draggedFigure?.id)) {
-            visibleFigures.push(this.env.model.getters.getFigure(this.env.model.getters.getActiveSheetId(), this.dnd.draggedFigure?.id));
+            const draggedFigure = this.env.model.getters.getFigure(this.env.model.getters.getActiveSheetId(), this.dnd.draggedFigure?.id);
+            if (draggedFigure) {
+                visibleFigures.push(draggedFigure);
+            }
         }
         return visibleFigures;
     }
@@ -48222,7 +49226,7 @@ class FiguresContainer extends owl.Component {
             this.dnd.verticalSnap = undefined;
             this.env.model.dispatch("UPDATE_FIGURE", { sheetId, id: figure.id, x, y });
         };
-        startDnd(onMouseMove, onMouseUp);
+        this.dnd.cancelDnd = startDnd(onMouseMove, onMouseUp);
     }
     /**
      * Initialize the resize of a figure with mouse movements
@@ -48270,7 +49274,7 @@ class FiguresContainer extends owl.Component {
             this.dnd.horizontalSnap = undefined;
             this.dnd.verticalSnap = undefined;
         };
-        startDnd(onMouseMove, onMouseUp);
+        this.dnd.cancelDnd = startDnd(onMouseMove, onMouseUp);
     }
     getOtherFigures(figId) {
         return this.getVisibleFigures().filter((f) => f.id !== figId);
@@ -49377,9 +50381,11 @@ class HeadersOverlay extends owl.Component {
 class GridRenderer {
     getters;
     renderer;
+    fingerprints;
     constructor(get) {
         this.getters = get(ModelStore).getters;
         this.renderer = get(RendererStore);
+        this.fingerprints = get(FormulaFingerprintStore);
         this.renderer.register(this);
     }
     get renderingLayers() {
@@ -49857,14 +50863,22 @@ class GridRenderer {
         const showFormula = this.getters.shouldShowFormulas();
         const { x, y, width, height } = this.getters.getVisibleRect(zone);
         const { verticalAlign } = this.getters.getCellStyle(position);
+        let style = this.getters.getCellComputedStyle(position);
+        if (this.fingerprints.isEnabled) {
+            const fingerprintColor = this.fingerprints.colors.get(position);
+            style = { ...style, fillColor: fingerprintColor };
+        }
+        const dataBarFill = this.fingerprints.isEnabled
+            ? undefined
+            : this.getters.getConditionalDataBar(position);
         const box = {
             x,
             y,
             width,
             height,
             border: this.getters.getCellComputedBorder(position) || undefined,
-            style: this.getters.getCellComputedStyle(position),
-            dataBarFill: this.getters.getConditionalDataBar(position),
+            style,
+            dataBarFill,
             verticalAlign,
             isError: (cell.type === CellValueType.error && !!cell.message) ||
                 this.getters.isDataValidationInvalid(position),
@@ -49889,7 +50903,6 @@ class GridRenderer {
         box.hasIcon = this.getters.doesCellHaveGridIcon(position);
         const headerIconWidth = box.hasIcon ? GRID_ICON_EDGE_LENGTH + GRID_ICON_MARGIN : 0;
         /** Content */
-        const style = this.getters.getCellComputedStyle(position);
         const wrapping = style.wrapping || "overflow";
         const wrapText = wrapping === "wrap" && !showFormula;
         const maxWidth = width - 2 * MIN_CELL_TEXT_MARGIN;
@@ -51867,62 +52880,6 @@ class BordersPlugin extends CorePlugin {
     }
 }
 
-class PositionMap {
-    map = {};
-    constructor(entries = []) {
-        for (const [position, value] of entries) {
-            this.set(position, value);
-        }
-    }
-    set({ sheetId, col, row }, value) {
-        const map = this.map;
-        if (!map[sheetId]) {
-            map[sheetId] = {};
-        }
-        if (!map[sheetId][col]) {
-            map[sheetId][col] = {};
-        }
-        map[sheetId][col][row] = value;
-    }
-    get({ sheetId, col, row }) {
-        return this.map[sheetId]?.[col]?.[row];
-    }
-    getSheet(sheetId) {
-        return this.map[sheetId];
-    }
-    has({ sheetId, col, row }) {
-        return this.map[sheetId]?.[col]?.[row] !== undefined;
-    }
-    delete({ sheetId, col, row }) {
-        delete this.map[sheetId]?.[col]?.[row];
-    }
-    keys() {
-        const map = this.map;
-        const keys = [];
-        for (const sheetId in map) {
-            for (const col in map[sheetId]) {
-                for (const row in map[sheetId][col]) {
-                    keys.push({ sheetId, col: parseInt(col), row: parseInt(row) });
-                }
-            }
-        }
-        return keys;
-    }
-    keysForSheet(sheetId) {
-        const map = this.map[sheetId];
-        if (!map) {
-            return [];
-        }
-        const keys = [];
-        for (const col in map) {
-            for (const row in map[col]) {
-                keys.push({ sheetId, col: parseInt(col), row: parseInt(row) });
-            }
-        }
-        return keys;
-    }
-}
-
 /**
  * Core Plugin
  *
@@ -52361,7 +53318,7 @@ class CellPlugin extends CorePlugin {
         const before = this.getters.getCell({ sheetId, col, row });
         const hasContent = "content" in after || "formula" in after;
         // Compute the new cell properties
-        const afterContent = hasContent ? replaceSpecialSpaces(after?.content) : before?.content || "";
+        const afterContent = hasContent ? replaceNewLines(after?.content) : before?.content || "";
         let style;
         if (after.style !== undefined) {
             style = after.style || undefined;
@@ -55306,6 +56263,9 @@ class SheetPlugin extends CorePlugin {
         };
     }
     getUnboundedZone(sheetId, zone) {
+        if (zone.bottom === undefined || zone.right === undefined) {
+            return zone;
+        }
         const isFullRow = zone.left === 0 && zone.right === this.getNumberCols(sheetId) - 1;
         const isFullCol = zone.top === 0 && zone.bottom === this.getNumberRows(sheetId) - 1;
         return {
@@ -59589,66 +60549,25 @@ class EvaluationConditionalFormatPlugin extends UIPlugin {
             return;
         }
         const zone = this.getters.getRangeFromSheetXC(sheetId, range).zone;
-        const colorCellArgs = [];
+        const colorThresholds = [{ value: minValue, color: rule.minimum.color }];
         if (rule.midpoint && midValue) {
-            colorCellArgs.push({
-                minValue,
-                minColor: rule.minimum.color,
-                colorDiffUnit: this.computeColorDiffUnits(minValue, midValue, rule.minimum.color, rule.midpoint.color),
-            });
-            colorCellArgs.push({
-                minValue: midValue,
-                minColor: rule.midpoint.color,
-                colorDiffUnit: this.computeColorDiffUnits(midValue, maxValue, rule.midpoint.color, rule.maximum.color),
-            });
-        }
-        else {
-            colorCellArgs.push({
-                minValue,
-                minColor: rule.minimum.color,
-                colorDiffUnit: this.computeColorDiffUnits(minValue, maxValue, rule.minimum.color, rule.maximum.color),
-            });
+            colorThresholds.push({ value: midValue, color: rule.midpoint.color });
         }
+        colorThresholds.push({ value: maxValue, color: rule.maximum.color });
+        const colorScale = getColorScale(colorThresholds);
         for (let row = zone.top; row <= zone.bottom; row++) {
             for (let col = zone.left; col <= zone.right; col++) {
                 const cell = this.getters.getEvaluatedCell({ sheetId, col, row });
                 if (cell.type === CellValueType.number) {
                     const value = clip(cell.value, minValue, maxValue);
-                    let color;
-                    if (colorCellArgs.length === 2 && midValue) {
-                        color =
-                            value <= midValue
-                                ? this.colorCell(value, colorCellArgs[0].minValue, colorCellArgs[0].minColor, colorCellArgs[0].colorDiffUnit)
-                                : this.colorCell(value, colorCellArgs[1].minValue, colorCellArgs[1].minColor, colorCellArgs[1].colorDiffUnit);
-                    }
-                    else {
-                        color = this.colorCell(value, colorCellArgs[0].minValue, colorCellArgs[0].minColor, colorCellArgs[0].colorDiffUnit);
-                    }
                     if (!computedStyle[col])
                         computedStyle[col] = [];
                     computedStyle[col][row] = computedStyle[col]?.[row] || {};
-                    computedStyle[col][row].fillColor = colorNumberString(color);
+                    computedStyle[col][row].fillColor = colorScale(value);
                 }
             }
         }
     }
-    computeColorDiffUnits(minValue, maxValue, minColor, maxColor) {
-        const deltaValue = maxValue - minValue;
-        const deltaColorR = ((minColor >> 16) % 256) - ((maxColor >> 16) % 256);
-        const deltaColorG = ((minColor >> 8) % 256) - ((maxColor >> 8) % 256);
-        const deltaColorB = (minColor % 256) - (maxColor % 256);
-        const colorDiffUnitR = deltaColorR / deltaValue;
-        const colorDiffUnitG = deltaColorG / deltaValue;
-        const colorDiffUnitB = deltaColorB / deltaValue;
-        return [colorDiffUnitR, colorDiffUnitG, colorDiffUnitB];
-    }
-    colorCell(value, minValue, minColor, colorDiffUnit) {
-        const [colorDiffUnitR, colorDiffUnitG, colorDiffUnitB] = colorDiffUnit;
-        const r = Math.round(((minColor >> 16) % 256) - colorDiffUnitR * (value - minValue));
-        const g = Math.round(((minColor >> 8) % 256) - colorDiffUnitG * (value - minValue));
-        const b = Math.round((minColor % 256) - colorDiffUnitB * (value - minValue));
-        return (r << 16) | (g << 8) | b;
-    }
     /**
      * Execute the predicate to know if a conditional formatting rule should be applied to a cell
      */
@@ -60274,7 +61193,7 @@ function withPivotPresentationLayer (PivotClass) {
         }
         getValuesToAggregate(measure, domain) {
             const { rowDomain, colDomain } = domainToColRowDomain(this, domain);
-            const table = this.getTableStructure();
+            const table = super.getTableStructure();
             const values = [];
             if (colDomain.length === 0 &&
                 rowDomain.length < this.definition.rows.length &&
@@ -60708,6 +61627,21 @@ function withPivotPresentationLayer (PivotClass) {
             }
             throw new Error(`Value ${result.value} is not a number`);
         }
+        getTableStructure() {
+            const table = super.getTableStructure();
+            this.sortTableStructure(table);
+            return table;
+        }
+        sortTableStructure(table) {
+            if (!this.definition.sortedColumn || table.isSorted) {
+                return;
+            }
+            const measure = this.definition.sortedColumn.measure;
+            const isSortValid = isSortedColumnValid(this.definition.sortedColumn, this);
+            if (isSortValid) {
+                table.sort(measure, this.definition.sortedColumn, (measure, domain) => this._getPivotCellValueAndFormat(measure, domain));
+            }
+        }
     }
     return PivotPresentationLayer;
 }
@@ -62483,23 +63417,6 @@ class Session extends EventBus {
     }
 }
 
-function randomChoice(arr) {
-    return arr[Math.floor(Math.random() * arr.length)];
-}
-const colors = [
-    "#ff851b",
-    "#0074d9",
-    "#7fdbff",
-    "#b10dc9",
-    "#39cccc",
-    "#f012be",
-    "#3d9970",
-    "#111111",
-    "#ff4136",
-    "#aaaaaa",
-    "#85144b",
-    "#001f3f",
-];
 class CollaborativePlugin extends UIPlugin {
     static getters = [
         "getClientsToDisplay",
@@ -62508,7 +63425,7 @@ class CollaborativePlugin extends UIPlugin {
         "isFullySynchronized",
     ];
     static layers = ["Selection"];
-    availableColors = new Set(colors);
+    availableColors = new AlternatingColorGenerator(12);
     colors = {};
     session;
     constructor(config) {
@@ -62519,14 +63436,6 @@ class CollaborativePlugin extends UIPlugin {
         return (position.row < this.getters.getNumberRows(position.sheetId) &&
             position.col < this.getters.getNumberCols(position.sheetId));
     }
-    chooseNewColor() {
-        if (this.availableColors.size === 0) {
-            this.availableColors = new Set(colors);
-        }
-        const color = randomChoice([...this.availableColors.values()]);
-        this.availableColors.delete(color);
-        return color;
-    }
     getClient() {
         return this.session.getClient();
     }
@@ -62561,7 +63470,7 @@ class CollaborativePlugin extends UIPlugin {
                 this.isPositionValid(client.position)) {
                 const position = client.position;
                 if (!this.colors[client.id]) {
-                    this.colors[client.id] = this.chooseNewColor();
+                    this.colors[client.id] = this.availableColors.next();
                 }
                 const color = this.colors[client.id];
                 clients.push({ ...client, position, color });
@@ -62798,7 +63707,7 @@ class FormatPlugin extends UIPlugin {
                 for (let row = zone.top; row <= zone.bottom; row++) {
                     const position = { sheetId, col, row };
                     const pivotCell = this.getters.getPivotCellFromPosition(position);
-                    if (pivotCell.type === "VALUE") {
+                    if (this.isSpilledPivotValueFormula(position, pivotCell)) {
                         measurePositions.push(position);
                         const pivotId = this.getters.getPivotIdFromPosition(position) || "";
                         measuresByPivotId[pivotId] ??= new Set();
@@ -62835,6 +63744,10 @@ class FormatPlugin extends UIPlugin {
             format,
         });
     }
+    isSpilledPivotValueFormula(position, pivotCell) {
+        const cell = this.getters.getCell(position);
+        return pivotCell.type === "VALUE" && !cell?.isFormula;
+    }
     /**
      * This function allows to adjust the quantity of decimal places after a decimal
      * point on cells containing number value. It does this by changing the cells
@@ -62885,6 +63798,69 @@ class FormatPlugin extends UIPlugin {
     }
 }
 
+class GeoFeaturePlugin extends UIPlugin {
+    static getters = [
+        "getGeoJsonFeatures",
+        "geoFeatureNameToId",
+        "getGeoChartAvailableRegions",
+    ];
+    geoJsonService;
+    geoJsonCache = {};
+    constructor(config) {
+        super(config);
+        this.geoJsonService = config.external.geoJsonService;
+    }
+    getGeoChartAvailableRegions() {
+        if (!this.geoJsonService) {
+            console.error("No geoJsonService provided to the model");
+            return [];
+        }
+        return this.geoJsonService.getAvailableRegions() || [];
+    }
+    getGeoJsonFeatures(region) {
+        if (!this.geoJsonService) {
+            console.error("No geoJsonService provided to the model");
+            return;
+        }
+        const cachedGeoJson = this.geoJsonCache[region];
+        if (cachedGeoJson instanceof Promise) {
+            return undefined;
+        }
+        if (cachedGeoJson !== undefined) {
+            return cachedGeoJson ?? undefined;
+        }
+        this.geoJsonCache[region] = new Promise(async (resolve) => {
+            const json = await this.geoJsonService?.getTopoJson(region);
+            this.geoJsonCache[region] = this.convertToGeoJson(json);
+            this.dispatch("EVALUATE_CHARTS");
+            resolve();
+        });
+        return undefined;
+    }
+    geoFeatureNameToId(region, featureName) {
+        if (!this.geoJsonService) {
+            console.error("No geoJsonService provided to the model");
+            return;
+        }
+        return this.geoJsonService.geoFeatureNameToId(region, featureName);
+    }
+    convertToGeoJson(json) {
+        if (!json) {
+            return null;
+        }
+        // TopoJSON
+        if (json.type === "Topology") {
+            const features = window.ChartGeo.topojson.feature(json, Object.values(json.objects)[0]);
+            return features.type === "FeatureCollection" ? features.features : [features];
+        }
+        // GeoJSON
+        else if (json.type === "FeatureCollection") {
+            return json.features;
+        }
+        throw new Error("Invalid TopoJSON");
+    }
+}
+
 class HeaderVisibilityUIPlugin extends UIPlugin {
     static getters = [
         "getNextVisibleCellPosition",
@@ -64422,10 +65398,13 @@ class TableResizeUI extends UIPlugin {
             case "RESIZE_TABLE": {
                 const table = this.getters.getCoreTableMatchingTopLeft(cmd.sheetId, cmd.zone);
                 this.dispatch("UPDATE_TABLE", { ...cmd });
-                if (!table || !table.config.automaticAutofill)
+                if (!table)
                     return;
-                const oldTableZone = table.range.zone;
                 const newTableZone = this.getters.getRangeFromRangeData(cmd.newTableRange).zone;
+                this.selection.selectCell(newTableZone.right, newTableZone.bottom);
+                if (!table.config.automaticAutofill)
+                    return;
+                const oldTableZone = table.range.zone;
                 if (newTableZone.bottom >= oldTableZone.bottom) {
                     for (let col = newTableZone.left; col <= newTableZone.right; col++) {
                         const autofillSource = { col, row: oldTableZone.bottom, sheetId: cmd.sheetId };
@@ -65631,15 +66610,23 @@ class GridSelectionPlugin extends UIPlugin {
         handler.paste({ zones: pasteTarget, sheetId }, data, { isCutOperation: true });
         const toRemove = isBasedBefore ? cmd.elements.map((el) => el + thickness) : cmd.elements;
         let currentIndex = cmd.base;
+        const resizingGroups = {};
         for (const element of toRemove) {
             const size = this.getters.getHeaderSize(cmd.sheetId, cmd.dimension, element);
+            const currentSize = this.getters.getHeaderSize(cmd.sheetId, cmd.dimension, currentIndex);
+            if (size != currentSize) {
+                resizingGroups[size] ??= [];
+                resizingGroups[size].push(currentIndex);
+                currentIndex += 1;
+            }
+        }
+        for (const size in resizingGroups) {
             this.dispatch("RESIZE_COLUMNS_ROWS", {
                 dimension: cmd.dimension,
                 sheetId: cmd.sheetId,
-                size,
-                elements: [currentIndex],
+                size: parseInt(size, 10),
+                elements: resizingGroups[size],
             });
-            currentIndex += 1;
         }
         this.dispatch("REMOVE_COLUMNS_ROWS", {
             dimension: cmd.dimension,
@@ -66221,6 +67208,7 @@ class SheetViewPlugin extends UIPlugin {
                 break;
             case "DELETE_SHEET":
                 this.cleanViewports();
+                this.sheetsWithDirtyViewports.delete(cmd.sheetId);
                 break;
             case "ACTIVATE_SHEET":
                 this.sheetsWithDirtyViewports.add(cmd.sheetIdTo);
@@ -66871,7 +67859,8 @@ const featurePluginRegistry = new Registry()
     .add("data_cleanup", DataCleanupPlugin)
     .add("table_autofill", TableAutofillPlugin)
     .add("table_ui_resize", TableResizeUI)
-    .add("datavalidation_insert", DataValidationInsertionPlugin);
+    .add("datavalidation_insert", DataValidationInsertionPlugin)
+    .add("geo_features", GeoFeaturePlugin);
 // Plugins which have a state, but which should not be shared in collaborative
 const statefulUIPluginRegistry = new Registry()
     .add("selection", GridSelectionPlugin)
@@ -68615,8 +69604,8 @@ css /* scss */ `
   .o-topbar-composer {
     height: fit-content;
     margin-top: -1px;
+    margin-bottom: -1px;
     border: 1px solid;
-    z-index: ${ComponentsImportance.TopBarComposer};
     font-family: ${DEFAULT_FONT};
 
     .o-composer:empty:not(:focus):not(.active)::before {
@@ -68674,6 +69663,7 @@ class TopBarComposer extends owl.Component {
         }
         return cssPropertiesToCss({
             "border-color": SELECTION_BORDER_COLOR,
+            "z-index": String(ComponentsImportance.TopBarComposer),
         });
     }
     onFocus(selection) {
@@ -68782,6 +69772,15 @@ css /* scss */ `
       }
     }
 
+    .irregularity-map {
+      border-top: 1px solid ${SEPARATOR_COLOR};
+      height: ${TOPBAR_TOOLBAR_HEIGHT}px;
+
+      .alert-info {
+        border-left: 3px solid ${ALERT_INFO_BORDER};
+      }
+    }
+
     .o-topbar-composer {
       flex-grow: 1;
     }
@@ -68875,8 +69874,10 @@ class TopBar extends owl.Component {
     formatNumberMenuItemSpec = formatNumberMenuItemSpec;
     isntToolbarMenu = false;
     composerFocusStore;
+    fingerprints;
     setup() {
         this.composerFocusStore = useStore(ComposerFocusStore);
+        this.fingerprints = useStore(FormulaFingerprintStore);
         owl.useExternalListener(window, "click", this.onExternalClick);
         owl.onWillStart(() => this.updateCellState());
         owl.onWillUpdateProps(() => this.updateCellState());
@@ -69347,7 +70348,7 @@ class Spreadsheet extends owl.Component {
             properties["grid-template-rows"] = `auto`;
         }
         else {
-            properties["grid-template-rows"] = `${TOPBAR_HEIGHT}px auto ${BOTTOMBAR_HEIGHT + 1}px`;
+            properties["grid-template-rows"] = `max-content auto ${BOTTOMBAR_HEIGHT + 1}px`;
         }
         properties["grid-template-columns"] = `auto ${this.sidePanel.panelSize}px`;
         return cssPropertiesToCss(properties);
@@ -70425,9 +71426,6 @@ class SelectionStreamProcessorImpl {
     getBackToDefault() {
         this.stream.getBackToDefault();
     }
-    getAnchor() {
-        return this.anchor;
-    }
     modifyAnchor(anchor, mode, options) {
         const sheetId = this.getters.getActiveSheetId();
         anchor = {
@@ -73359,6 +74357,7 @@ class Model extends EventBus {
             session: this.session,
             defaultCurrency: this.config.defaultCurrency,
             customColors: this.config.customColors || [],
+            external: this.config.external,
         };
     }
     // ---------------------------------------------------------------------------
@@ -73590,7 +74589,6 @@ const SPREADSHEET_DIMENSIONS = {
     MIN_COL_WIDTH,
     HEADER_HEIGHT,
     HEADER_WIDTH,
-    TOPBAR_HEIGHT,
     BOTTOMBAR_HEIGHT,
     DEFAULT_CELL_WIDTH,
     DEFAULT_CELL_HEIGHT,
@@ -73831,6 +74829,6 @@ exports.tokenColors = tokenColors;
 exports.tokenize = tokenize;
 
 
-__info__.version = "18.1.0-alpha.7";
-__info__.date = "2024-12-05T10:40:26.512Z";
-__info__.hash = "7b1c39b";
+__info__.version = "18.1.0-alpha.8";
+__info__.date = "2024-12-19T07:49:54.421Z";
+__info__.hash = "87a1567";