@odoo/o-spreadsheet 18.0.10 → 18.0.12

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.0.10
- * @date 2025-01-15T08:05:47.616Z
- * @hash 94c45c7
+ * @version 18.0.12
+ * @date 2025-01-29T06:24:22.122Z
+ * @hash a881cff
  */
 
 'use strict';
@@ -4211,15 +4211,18 @@ function dichotomicSearch(data, target, mode, sortOrder, rangeLength, getValueIn
     let currentIndex;
     let currentVal;
     let currentType;
+    const getValue = sortOrder === "desc"
+        ? (i) => normalizeValue(getValueInData(data, rangeLength - i - 1))
+        : (i) => normalizeValue(getValueInData(data, i));
     while (indexRight - indexLeft >= 0) {
         indexMedian = Math.floor((indexLeft + indexRight) / 2);
         currentIndex = indexMedian;
-        currentVal = normalizeValue(getValueInData(data, currentIndex));
+        currentVal = getValue(currentIndex);
         currentType = typeof currentVal;
         // 1 - linear search to find value with the same type
         while (indexLeft < currentIndex && targetType !== currentType) {
             currentIndex--;
-            currentVal = normalizeValue(getValueInData(data, currentIndex));
+            currentVal = getValue(currentIndex);
             currentType = typeof currentVal;
         }
         if (currentType !== targetType || currentVal === undefined || currentVal === null) {
@@ -4235,8 +4238,7 @@ function dichotomicSearch(data, target, mode, sortOrder, rangeLength, getValueIn
             if (matchVal === undefined ||
                 matchVal === null ||
                 matchVal < currentVal ||
-                (matchVal === currentVal && sortOrder === "asc" && matchValIndex < currentIndex) ||
-                (matchVal === currentVal && sortOrder === "desc" && matchValIndex > currentIndex)) {
+                (matchVal === currentVal && matchValIndex < currentIndex)) {
                 matchVal = currentVal;
                 matchValIndex = currentIndex;
             }
@@ -4244,15 +4246,13 @@ function dichotomicSearch(data, target, mode, sortOrder, rangeLength, getValueIn
         else if (mode === "nextGreater" && currentVal >= _target) {
             if (matchVal === undefined ||
                 matchVal > currentVal ||
-                (matchVal === currentVal && sortOrder === "asc" && matchValIndex < currentIndex) ||
-                (matchVal === currentVal && sortOrder === "desc" && matchValIndex > currentIndex)) {
+                (matchVal === currentVal && matchValIndex < currentIndex)) {
                 matchVal = currentVal;
                 matchValIndex = currentIndex;
             }
         }
         // 3 - give new indexes for the Binary search
-        if ((sortOrder === "asc" && currentVal > _target) ||
-            (sortOrder === "desc" && currentVal <= _target)) {
+        if (currentVal > _target || (mode === "strict" && currentVal === _target)) {
             indexRight = currentIndex - 1;
         }
         else {
@@ -4260,7 +4260,10 @@ function dichotomicSearch(data, target, mode, sortOrder, rangeLength, getValueIn
         }
     }
     // note that valMinIndex could be 0
-    return matchValIndex !== undefined ? matchValIndex : -1;
+    if (matchValIndex === undefined) {
+        return -1;
+    }
+    return sortOrder === "desc" ? rangeLength - matchValIndex - 1 : matchValIndex;
 }
 /**
  * Perform a linear search and return the index of the match.
@@ -4392,47 +4395,83 @@ function isDataNonEmpty(data) {
     return true;
 }
 
-function toCriterionDateNumber(dateValue) {
-    const today = DateTime.now();
-    switch (dateValue) {
-        case "today":
-            return jsDateToNumber(today);
-        case "yesterday":
-            return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() - 1)));
-        case "tomorrow":
-            return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() + 1)));
-        case "lastWeek":
-            return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() - 7)));
-        case "lastMonth":
-            return jsDateToNumber(DateTime.fromTimestamp(today.setMonth(today.getMonth() - 1)));
-        case "lastYear":
-            return jsDateToNumber(DateTime.fromTimestamp(today.setFullYear(today.getFullYear() - 1)));
-    }
+/**
+ * Add the `https` prefix to the url if it's missing
+ */
+function withHttps(url) {
+    return !/^https?:\/\//i.test(url) ? `https://${url}` : url;
 }
-/** Get all the dates values of a criterion converted to numbers, converting date values such as "today" to actual dates  */
-function getDateNumberCriterionValues(criterion, locale) {
-    if ("dateValue" in criterion && criterion.dateValue !== "exactDate") {
-        return [toCriterionDateNumber(criterion.dateValue)];
-    }
-    return criterion.values.map((value) => valueToDateNumber(value, locale));
+const urlRegistry = new Registry();
+function createWebLink(url, label) {
+    url = withHttps(url);
+    return {
+        url,
+        label: label || url,
+        isExternal: true,
+        isUrlEditable: true,
+    };
 }
-/** Convert the criterion values to numbers. Return undefined values if they cannot be converted to numbers. */
-function getCriterionValuesAsNumber(criterion, locale) {
-    return criterion.values.map((value) => tryToNumber(value, locale));
+urlRegistry.add("sheet_URL", {
+    match: (url) => isSheetUrl(url),
+    createLink: (url, label) => {
+        return {
+            label,
+            url,
+            isExternal: false,
+            isUrlEditable: false,
+        };
+    },
+    urlRepresentation(url, getters) {
+        const sheetId = parseSheetUrl(url);
+        return getters.tryGetSheetName(sheetId) || _t("Invalid sheet");
+    },
+    open(url, env) {
+        const sheetId = parseSheetUrl(url);
+        const result = env.model.dispatch("ACTIVATE_SHEET", {
+            sheetIdFrom: env.model.getters.getActiveSheetId(),
+            sheetIdTo: sheetId,
+        });
+        if (result.isCancelledBecause("SheetIsHidden" /* CommandResult.SheetIsHidden */)) {
+            env.notifyUser({
+                type: "warning",
+                sticky: false,
+                text: _t("Cannot open the link because the linked sheet is hidden."),
+            });
+        }
+    },
+    sequence: 0,
+});
+const WebUrlSpec = {
+    createLink: createWebLink,
+    match: (url) => isWebLink(url),
+    open: (url) => window.open(url, "_blank"),
+    urlRepresentation: (url) => url,
+    sequence: 0,
+};
+function findMatchingSpec(url) {
+    return (urlRegistry
+        .getAll()
+        .sort((a, b) => a.sequence - b.sequence)
+        .find((urlType) => urlType.match(url)) || WebUrlSpec);
 }
-
-const MAX_DELAY = 140;
-const MIN_DELAY = 20;
-const ACCELERATION = 0.035;
-/**
- * Decreasing exponential function used to determine the "speed" of edge-scrolling
- * as the timeout delay.
- *
- * Returns a timeout delay in milliseconds.
- */
-function scrollDelay(value) {
-    // decreasing exponential from MAX_DELAY to MIN_DELAY
-    return MIN_DELAY + (MAX_DELAY - MIN_DELAY) * Math.exp(-ACCELERATION * (value - 1));
+function urlRepresentation(link, getters) {
+    return findMatchingSpec(link.url).urlRepresentation(link.url, getters);
+}
+function openLink(link, env) {
+    findMatchingSpec(link.url).open(link.url, env);
+}
+function detectLink(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    if (isMarkdownLink(value)) {
+        const { label, url } = parseMarkdownLink(value);
+        return findMatchingSpec(url).createLink(url, label);
+    }
+    else if (isWebLink(value)) {
+        return createWebLink(value);
+    }
+    return undefined;
 }
 
 function tokenizeFormat(str) {
@@ -5494,6 +5533,193 @@ function isTextFormat(format) {
     }
 }
 
+function evaluateLiteral(literalCell, localeFormat) {
+    const value = isTextFormat(localeFormat.format) ? literalCell.content : literalCell.parsedValue;
+    const functionResult = { value, format: localeFormat.format };
+    return createEvaluatedCell(functionResult, localeFormat.locale);
+}
+function parseLiteral(content, locale) {
+    if (content.startsWith("=")) {
+        throw new Error(`Cannot parse "${content}" because it's not a literal value. It's a formula`);
+    }
+    if (content === "") {
+        return null;
+    }
+    if (isNumber(content, DEFAULT_LOCALE)) {
+        return parseNumber(content, DEFAULT_LOCALE);
+    }
+    const internalDate = parseDateTime(content, locale);
+    if (internalDate) {
+        return internalDate.value;
+    }
+    if (isBoolean(content)) {
+        return content.toUpperCase() === "TRUE" ? true : false;
+    }
+    return content;
+}
+function createEvaluatedCell(functionResult, locale = DEFAULT_LOCALE, cell) {
+    const link = detectLink(functionResult.value);
+    if (!link) {
+        return _createEvaluatedCell(functionResult, locale, cell);
+    }
+    const value = parseLiteral(link.label, locale);
+    const format = functionResult.format ||
+        (typeof value === "number"
+            ? detectDateFormat(link.label, locale) || detectNumberFormat(link.label)
+            : undefined);
+    const linkPayload = {
+        value,
+        format,
+    };
+    return {
+        ..._createEvaluatedCell(linkPayload, locale, cell),
+        link,
+    };
+}
+function _createEvaluatedCell(functionResult, locale, cell) {
+    let { value, format, message } = functionResult;
+    format = cell?.format || format;
+    const formattedValue = formatValue(value, { format, locale });
+    if (isEvaluationError(value)) {
+        return errorCell(value, message);
+    }
+    if (isTextFormat(format)) {
+        // TO DO:
+        // with the next line, the value of the cell is transformed depending on the format.
+        // This shouldn't happen, by doing this, the formulas handling numbers are not able
+        // to interpret the value as a number.
+        return textCell(toString(value), format, formattedValue);
+    }
+    if (value === null) {
+        return emptyCell(format);
+    }
+    if (typeof value === "number") {
+        if (isDateTimeFormat(format || "")) {
+            return dateTimeCell(value, format, formattedValue);
+        }
+        return numberCell(value, format, formattedValue);
+    }
+    if (typeof value === "boolean") {
+        return booleanCell(value, format, formattedValue);
+    }
+    return textCell(value, format, formattedValue);
+}
+function textCell(value, format, formattedValue) {
+    return {
+        value,
+        format,
+        formattedValue,
+        type: CellValueType.text,
+        isAutoSummable: true,
+        defaultAlign: "left",
+    };
+}
+function numberCell(value, format, formattedValue) {
+    return {
+        value: value || 0, // necessary to avoid "-0" and NaN values,
+        format,
+        formattedValue,
+        type: CellValueType.number,
+        isAutoSummable: true,
+        defaultAlign: "right",
+    };
+}
+const emptyCell = memoize(function emptyCell(format) {
+    return {
+        value: null,
+        format,
+        formattedValue: "",
+        type: CellValueType.empty,
+        isAutoSummable: true,
+        defaultAlign: "left",
+    };
+});
+function dateTimeCell(value, format, formattedValue) {
+    return {
+        value,
+        format,
+        formattedValue,
+        type: CellValueType.number,
+        isAutoSummable: false,
+        defaultAlign: "right",
+    };
+}
+function booleanCell(value, format, formattedValue) {
+    return {
+        value,
+        format,
+        formattedValue,
+        type: CellValueType.boolean,
+        isAutoSummable: false,
+        defaultAlign: "center",
+    };
+}
+function errorCell(value, message) {
+    return {
+        value,
+        formattedValue: value,
+        message,
+        type: CellValueType.error,
+        isAutoSummable: false,
+        defaultAlign: "center",
+    };
+}
+
+function toCriterionDateNumber(dateValue) {
+    const today = DateTime.now();
+    switch (dateValue) {
+        case "today":
+            return jsDateToNumber(today);
+        case "yesterday":
+            return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() - 1)));
+        case "tomorrow":
+            return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() + 1)));
+        case "lastWeek":
+            return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() - 7)));
+        case "lastMonth":
+            return jsDateToNumber(DateTime.fromTimestamp(today.setMonth(today.getMonth() - 1)));
+        case "lastYear":
+            return jsDateToNumber(DateTime.fromTimestamp(today.setFullYear(today.getFullYear() - 1)));
+    }
+}
+/** Get all the dates values of a criterion converted to numbers, converting date values such as "today" to actual dates  */
+function getDateNumberCriterionValues(criterion, locale) {
+    if ("dateValue" in criterion && criterion.dateValue !== "exactDate") {
+        return [toCriterionDateNumber(criterion.dateValue)];
+    }
+    return criterion.values.map((value) => valueToDateNumber(value, locale));
+}
+/** Convert the criterion values to numbers. Return undefined values if they cannot be converted to numbers. */
+function getCriterionValuesAsNumber(criterion, locale) {
+    return criterion.values.map((value) => tryToNumber(value, locale));
+}
+function getDateCriterionFormattedValues(values, locale) {
+    return values.map((valueStr) => {
+        if (valueStr.startsWith("=")) {
+            return valueStr;
+        }
+        const value = parseLiteral(valueStr, locale);
+        if (typeof value === "number") {
+            return formatValue(value, { format: locale.dateFormat, locale });
+        }
+        return "";
+    });
+}
+
+const MAX_DELAY = 140;
+const MIN_DELAY = 20;
+const ACCELERATION = 0.035;
+/**
+ * Decreasing exponential function used to determine the "speed" of edge-scrolling
+ * as the timeout delay.
+ *
+ * Returns a timeout delay in milliseconds.
+ */
+function scrollDelay(value) {
+    // decreasing exponential from MAX_DELAY to MIN_DELAY
+    return MIN_DELAY + (MAX_DELAY - MIN_DELAY) * Math.exp(-ACCELERATION * (value - 1));
+}
+
 class RangeImpl {
     getSheetSize;
     _zone;
@@ -9231,13 +9457,13 @@ function toExcelDataset(getters, ds) {
     else if (ds.labelCell) {
         label = {
             reference: getters.getRangeString(ds.labelCell, "forceSheetReference", {
-                useFixedReference: true,
+                useBoundedReference: true,
             }),
         };
     }
     return {
         label,
-        range: getters.getRangeString(dataRange, "forceSheetReference", { useFixedReference: true }),
+        range: getters.getRangeString(dataRange, "forceSheetReference", { useBoundedReference: true }),
         backgroundColor: ds.backgroundColor,
         rightYAxis: ds.rightYAxis,
     };
@@ -9252,7 +9478,7 @@ function toExcelLabelRange(getters, labelRange, shouldRemoveFirstLabel) {
         zone.top = zone.top + 1;
     }
     const range = labelRange.clone({ zone });
-    return getters.getRangeString(range, "forceSheetReference", { useFixedReference: true });
+    return getters.getRangeString(range, "forceSheetReference", { useBoundedReference: true });
 }
 /**
  * Transform a chart definition which supports dataSets (dataSets and LabelRange)
@@ -9416,11 +9642,7 @@ function interpolateData(config, values, labels, newLabels) {
     if (values.length < 2 || labels.length < 2 || newLabels.length === 0) {
         return [];
     }
-    const labelMin = Math.min(...labels);
-    const labelMax = Math.max(...labels);
-    const labelRange = labelMax - labelMin;
-    const normalizedLabels = labels.map((v) => (v - labelMin) / labelRange);
-    const normalizedNewLabels = newLabels.map((v) => (v - labelMin) / labelRange);
+    const { normalizedLabels, normalizedNewLabels } = normalizeLabels(labels, newLabels, config);
     try {
         switch (config.type) {
             case "polynomial": {
@@ -9459,6 +9681,30 @@ function interpolateData(config, values, labels, newLabels) {
         return Array.from({ length: newLabels.length }, () => NaN);
     }
 }
+function normalizeLabels(labels, newLabels, config) {
+    let normalizedLabels = [];
+    let normalizedNewLabels = [];
+    if (config.type === "logarithmic") {
+        // Logarithmic trends in charts are used to visualize proportional growth or
+        // relative changes. Therefore, we change the normalization technique for
+        // logarithmic trend lines for a better fit. The method used here is Max Absolute
+        // Scaling. This Technique is ideal for data spanning several orders of magnitude,
+        // as it balances differences between small and large values by compressing larger
+        // values while preserving proportionality and ensuring all values are scaled relative
+        // to the largest magnitude.
+        const labelMax = Math.max(...labels.map(Math.abs));
+        normalizedLabels = labels.map((l) => l / labelMax);
+        normalizedNewLabels = newLabels.map((l) => l / labelMax);
+    }
+    else {
+        const labelMax = Math.max(...labels);
+        const labelMin = Math.min(...labels);
+        const labelRange = labelMax - labelMin;
+        normalizedLabels = labels.map((l) => (l - labelMax) / labelRange);
+        normalizedNewLabels = newLabels.map((l) => (l - labelMax) / labelRange);
+    }
+    return { normalizedLabels, normalizedNewLabels };
+}
 function formatTickValue(localeFormat) {
     return (value) => {
         value = Number(value);
@@ -22095,217 +22341,6 @@ autoCompleteProviders.add("sheet_names", {
     },
 });
 
-/**
- * Add the `https` prefix to the url if it's missing
- */
-function withHttps(url) {
-    return !/^https?:\/\//i.test(url) ? `https://${url}` : url;
-}
-const urlRegistry = new Registry();
-function createWebLink(url, label) {
-    url = withHttps(url);
-    return {
-        url,
-        label: label || url,
-        isExternal: true,
-        isUrlEditable: true,
-    };
-}
-urlRegistry.add("sheet_URL", {
-    match: (url) => isSheetUrl(url),
-    createLink: (url, label) => {
-        return {
-            label,
-            url,
-            isExternal: false,
-            isUrlEditable: false,
-        };
-    },
-    urlRepresentation(url, getters) {
-        const sheetId = parseSheetUrl(url);
-        return getters.tryGetSheetName(sheetId) || _t("Invalid sheet");
-    },
-    open(url, env) {
-        const sheetId = parseSheetUrl(url);
-        const result = env.model.dispatch("ACTIVATE_SHEET", {
-            sheetIdFrom: env.model.getters.getActiveSheetId(),
-            sheetIdTo: sheetId,
-        });
-        if (result.isCancelledBecause("SheetIsHidden" /* CommandResult.SheetIsHidden */)) {
-            env.notifyUser({
-                type: "warning",
-                sticky: false,
-                text: _t("Cannot open the link because the linked sheet is hidden."),
-            });
-        }
-    },
-    sequence: 0,
-});
-const WebUrlSpec = {
-    createLink: createWebLink,
-    match: (url) => isWebLink(url),
-    open: (url) => window.open(url, "_blank"),
-    urlRepresentation: (url) => url,
-    sequence: 0,
-};
-function findMatchingSpec(url) {
-    return (urlRegistry
-        .getAll()
-        .sort((a, b) => a.sequence - b.sequence)
-        .find((urlType) => urlType.match(url)) || WebUrlSpec);
-}
-function urlRepresentation(link, getters) {
-    return findMatchingSpec(link.url).urlRepresentation(link.url, getters);
-}
-function openLink(link, env) {
-    findMatchingSpec(link.url).open(link.url, env);
-}
-function detectLink(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    if (isMarkdownLink(value)) {
-        const { label, url } = parseMarkdownLink(value);
-        return findMatchingSpec(url).createLink(url, label);
-    }
-    else if (isWebLink(value)) {
-        return createWebLink(value);
-    }
-    return undefined;
-}
-
-function evaluateLiteral(literalCell, localeFormat) {
-    const value = isTextFormat(localeFormat.format) ? literalCell.content : literalCell.parsedValue;
-    const functionResult = { value, format: localeFormat.format };
-    return createEvaluatedCell(functionResult, localeFormat.locale);
-}
-function parseLiteral(content, locale) {
-    if (content.startsWith("=")) {
-        throw new Error(`Cannot parse "${content}" because it's not a literal value. It's a formula`);
-    }
-    if (content === "") {
-        return null;
-    }
-    if (isNumber(content, DEFAULT_LOCALE)) {
-        return parseNumber(content, DEFAULT_LOCALE);
-    }
-    const internalDate = parseDateTime(content, locale);
-    if (internalDate) {
-        return internalDate.value;
-    }
-    if (isBoolean(content)) {
-        return content.toUpperCase() === "TRUE" ? true : false;
-    }
-    return content;
-}
-function createEvaluatedCell(functionResult, locale = DEFAULT_LOCALE, cell) {
-    const link = detectLink(functionResult.value);
-    if (!link) {
-        return _createEvaluatedCell(functionResult, locale, cell);
-    }
-    const value = parseLiteral(link.label, locale);
-    const format = functionResult.format ||
-        (typeof value === "number"
-            ? detectDateFormat(link.label, locale) || detectNumberFormat(link.label)
-            : undefined);
-    const linkPayload = {
-        value,
-        format,
-    };
-    return {
-        ..._createEvaluatedCell(linkPayload, locale, cell),
-        link,
-    };
-}
-function _createEvaluatedCell(functionResult, locale, cell) {
-    let { value, format, message } = functionResult;
-    format = cell?.format || format;
-    const formattedValue = formatValue(value, { format, locale });
-    if (isEvaluationError(value)) {
-        return errorCell(value, message);
-    }
-    if (isTextFormat(format)) {
-        // TO DO:
-        // with the next line, the value of the cell is transformed depending on the format.
-        // This shouldn't happen, by doing this, the formulas handling numbers are not able
-        // to interpret the value as a number.
-        return textCell(toString(value), format, formattedValue);
-    }
-    if (value === null) {
-        return emptyCell(format);
-    }
-    if (typeof value === "number") {
-        if (isDateTimeFormat(format || "")) {
-            return dateTimeCell(value, format, formattedValue);
-        }
-        return numberCell(value, format, formattedValue);
-    }
-    if (typeof value === "boolean") {
-        return booleanCell(value, format, formattedValue);
-    }
-    return textCell(value, format, formattedValue);
-}
-function textCell(value, format, formattedValue) {
-    return {
-        value,
-        format,
-        formattedValue,
-        type: CellValueType.text,
-        isAutoSummable: true,
-        defaultAlign: "left",
-    };
-}
-function numberCell(value, format, formattedValue) {
-    return {
-        value: value || 0, // necessary to avoid "-0" and NaN values,
-        format,
-        formattedValue,
-        type: CellValueType.number,
-        isAutoSummable: true,
-        defaultAlign: "right",
-    };
-}
-const emptyCell = memoize(function emptyCell(format) {
-    return {
-        value: null,
-        format,
-        formattedValue: "",
-        type: CellValueType.empty,
-        isAutoSummable: true,
-        defaultAlign: "left",
-    };
-});
-function dateTimeCell(value, format, formattedValue) {
-    return {
-        value,
-        format,
-        formattedValue,
-        type: CellValueType.number,
-        isAutoSummable: false,
-        defaultAlign: "right",
-    };
-}
-function booleanCell(value, format, formattedValue) {
-    return {
-        value,
-        format,
-        formattedValue,
-        type: CellValueType.boolean,
-        isAutoSummable: false,
-        defaultAlign: "center",
-    };
-}
-function errorCell(value, message) {
-    return {
-        value,
-        formattedValue: value,
-        message,
-        type: CellValueType.error,
-        isAutoSummable: false,
-        defaultAlign: "center",
-    };
-}
-
 /**
  * An AutofillModifierImplementation is used to describe how to handle a
  * AutofillModifier.
@@ -23451,6 +23486,10 @@ var WarningTypes;
     WarningTypes["CfIconSetEmptyIconNotSupported"] = "IconSets with empty icons";
     WarningTypes["BadlyFormattedHyperlink"] = "Badly formatted hyperlink";
     WarningTypes["NumFmtIdNotSupported"] = "Number format";
+    WarningTypes["TimeDataValidationNotSupported"] = "Time data validation rules";
+    WarningTypes["TextLengthDataValidationNotSupported"] = "Text length data validation rules";
+    WarningTypes["WholeNumberDataValidationNotSupported"] = "Whole number data validation rules";
+    WarningTypes["NotEqualDateDataValidationNotSupported"] = "Not equal date data validation rules";
 })(WarningTypes || (WarningTypes = {}));
 class XLSXImportWarningManager {
     _parsingWarnings = new Set();
@@ -23829,6 +23868,25 @@ const IMAGE_EXTENSION_TO_MIMETYPE_MAPPING = {
     webp: "image/webp",
     jpg: "image/jpeg",
 };
+const XLSX_DV_DECIMAL_OPERATOR_MAPPING = {
+    between: "isBetween",
+    notBetween: "isNotBetween",
+    equal: "isEqual",
+    notEqual: "isNotEqual",
+    greaterThan: "isGreaterThan",
+    greaterThanOrEqual: "isGreaterOrEqualTo",
+    lessThan: "isLessThan",
+    lessThanOrEqual: "isLessOrEqualTo",
+};
+const XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING = {
+    between: "dateIsBetween",
+    notBetween: "dateIsNotBetween",
+    equal: "dateIs",
+    greaterThan: "dateIsAfter",
+    greaterThanOrEqual: "dateIsOnOrAfter",
+    lessThan: "dateIsBefore",
+    lessThanOrEqual: "dateIsOnOrBefore",
+};
 
 /**
  * Most of the functions could stay private, but are exported for testing purposes
@@ -24598,6 +24656,20 @@ function getRowPosition(rowIndex, sheetData) {
     }
     return position / HEIGHT_FACTOR;
 }
+/**
+ * Convert the o-spreadsheet data validation decimal
+ * criterion type to the corresponding excel operator.
+ */
+function convertDecimalCriterionTypeToExcelOperator(operator) {
+    return Object.keys(XLSX_DV_DECIMAL_OPERATOR_MAPPING).find((key) => XLSX_DV_DECIMAL_OPERATOR_MAPPING[key] === operator);
+}
+/**
+ * Convert the o-spreadsheet data validation date
+ * criterion type to the corresponding excel operator.
+ */
+function convertDateCriterionTypeToExcelOperator(operator) {
+    return Object.keys(XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING).find((key) => XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING[key] === operator);
+}
 
 function convertFigures(sheetData) {
     let id = 1;
@@ -24707,6 +24779,112 @@ function getPositionFromAnchor(anchor, sheetData) {
     };
 }
 
+function convertDataValidationRules(xlsxDataValidations, warningManager) {
+    const dvRules = [];
+    let dvId = 1;
+    for (const dv of xlsxDataValidations) {
+        if (!dv) {
+            continue;
+        }
+        switch (dv.type) {
+            case "time":
+                warningManager.generateNotSupportedWarning(WarningTypes.TimeDataValidationNotSupported);
+                break;
+            case "textLength":
+                warningManager.generateNotSupportedWarning(WarningTypes.TextLengthDataValidationNotSupported);
+                break;
+            case "whole":
+                warningManager.generateNotSupportedWarning(WarningTypes.WholeNumberDataValidationNotSupported);
+                break;
+            case "decimal":
+                const decimalRule = convertDecimalRule(dvId++, dv);
+                dvRules.push(decimalRule);
+                break;
+            case "list":
+                const listRule = convertListrule(dvId++, dv);
+                dvRules.push(listRule);
+                break;
+            case "date":
+                if (dv.operator === "notEqual") {
+                    warningManager.generateNotSupportedWarning(WarningTypes.NotEqualDateDataValidationNotSupported);
+                    break;
+                }
+                const dateRule = convertDateRule(dvId++, dv);
+                dvRules.push(dateRule);
+                break;
+            case "custom":
+                const customRule = convertCustomRule(dvId++, dv);
+                dvRules.push(customRule);
+                break;
+        }
+    }
+    return dvRules;
+}
+function convertDecimalRule(id, dv) {
+    const values = [dv.formula1.toString()];
+    if (dv.formula2) {
+        values.push(dv.formula2.toString());
+    }
+    return {
+        id: id.toString(),
+        ranges: dv.sqref,
+        isBlocking: dv.errorStyle !== "warning",
+        criterion: {
+            type: XLSX_DV_DECIMAL_OPERATOR_MAPPING[dv.operator],
+            values,
+        },
+    };
+}
+function convertListrule(id, dv) {
+    const formula1 = dv.formula1.toString();
+    const isRangeRule = rangeReference.test(formula1);
+    return {
+        id: id.toString(),
+        ranges: dv.sqref,
+        isBlocking: dv.errorStyle !== "warning",
+        criterion: {
+            type: isRangeRule ? "isValueInRange" : "isValueInList",
+            values: isRangeRule ? [formula1] : formula1.replaceAll('"', "").split(","),
+            displayStyle: "arrow",
+        },
+    };
+}
+function convertDateRule(id, dv) {
+    let criterion;
+    const values = [dv.formula1.toString()];
+    if (dv.formula2) {
+        values.push(dv.formula2.toString());
+        criterion = {
+            type: XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING[dv.operator],
+            values: getDateCriterionFormattedValues(values, DEFAULT_LOCALE),
+        };
+    }
+    else {
+        criterion = {
+            type: XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING[dv.operator],
+            values: getDateCriterionFormattedValues(values, DEFAULT_LOCALE),
+            dateValue: "exactDate",
+        };
+    }
+    return {
+        id: id.toString(),
+        ranges: dv.sqref,
+        isBlocking: dv.errorStyle !== "warning",
+        criterion: criterion,
+    };
+}
+function convertCustomRule(id, dv) {
+    return {
+        id: id.toString(),
+        ranges: dv.sqref,
+        isBlocking: dv.errorStyle !== "warning",
+        criterion: {
+            type: "customFormula",
+            values: [`=${dv.formula1.toString()}`],
+        },
+    };
+}
+
 /**
  * Match external reference (ex. '[1]Sheet 3'!$B$4)
  *
@@ -24827,6 +25005,7 @@ function convertSheets(data, warningManager) {
             cols: convertCols(sheet, sheetDims[0], colHeaderGroups),
             rows: convertRows(sheet, sheetDims[1], rowHeaderGroups),
             conditionalFormats: convertConditionalFormats(sheet.cfs, data.dxfs, warningManager),
+            dataValidationRules: convertDataValidationRules(sheet.dataValidations, warningManager),
             figures: convertFigures(sheet),
             isVisible: sheet.isVisible,
             panes: sheetOptions
@@ -26107,6 +26286,41 @@ class XlsxCfExtractor extends XlsxBaseExtractor {
     }
 }
 
+class XlsxDataValidationExtractor extends XlsxBaseExtractor {
+    theme;
+    constructor(sheetFile, xlsxStructure, warningManager, theme) {
+        super(sheetFile, xlsxStructure, warningManager);
+        this.theme = theme;
+    }
+    extractDataValidations() {
+        const dataValidations = this.mapOnElements({ parent: this.rootFile.file.xml, query: "worksheet > dataValidations > dataValidation" }, (dvElement) => {
+            return {
+                type: this.extractAttr(dvElement, "type", { required: true }).asString(),
+                operator: this.extractAttr(dvElement, "operator", {
+                    default: "between",
+                })?.asString(),
+                sqref: this.extractAttr(dvElement, "sqref", { required: true }).asString().split(" "),
+                errorStyle: this.extractAttr(dvElement, "errorStyle")?.asString(),
+                formula1: this.extractDataValidationFormula(dvElement, 1)[0],
+                formula2: this.extractDataValidationFormula(dvElement, 2)[0],
+                showErrorMessage: this.extractAttr(dvElement, "showErrorMessage")?.asBool(),
+                errorTitle: this.extractAttr(dvElement, "errorTitle")?.asString(),
+                error: this.extractAttr(dvElement, "error")?.asString(),
+                showInputMessage: this.extractAttr(dvElement, "showInputMessage")?.asBool(),
+                promptTitle: this.extractAttr(dvElement, "promptTitle")?.asString(),
+                prompt: this.extractAttr(dvElement, "prompt")?.asString(),
+                allowBlank: this.extractAttr(dvElement, "allowBlank")?.asBool(),
+            };
+        });
+        return dataValidations;
+    }
+    extractDataValidationFormula(dvElement, index) {
+        return this.mapOnElements({ parent: dvElement, query: `formula${index}` }, (cfFormulaElements) => {
+            return this.extractTextContent(cfFormulaElements, { required: true });
+        });
+    }
+}
+
 class XlsxChartExtractor extends XlsxBaseExtractor {
     extractChart() {
         return this.mapOnElements({ parent: this.rootFile.file.xml, query: "c:chartSpace" }, (rootChartElement) => {
@@ -26474,6 +26688,7 @@ class XlsxSheetExtractor extends XlsxBaseExtractor {
                 sharedFormulas: this.extractSharedFormulas(sheetElement),
                 merges: this.extractMerges(sheetElement),
                 cfs: this.extractConditionalFormats(),
+                dataValidations: this.extractDataValidations(),
                 figures: this.extractFigures(sheetElement),
                 hyperlinks: this.extractHyperLinks(sheetElement),
                 tables: this.extractTables(sheetElement),
@@ -26545,6 +26760,9 @@ class XlsxSheetExtractor extends XlsxBaseExtractor {
     extractConditionalFormats() {
         return new XlsxCfExtractor(this.rootFile, this.xlsxFileStructure, this.warningManager, this.theme).extractConditionalFormattings();
     }
+    extractDataValidations() {
+        return new XlsxDataValidationExtractor(this.rootFile, this.xlsxFileStructure, this.warningManager, this.theme).extractDataValidations();
+    }
     extractFigures(worksheet) {
         const figures = this.mapOnElements({ parent: worksheet, query: "drawing" }, (drawingElement) => {
             const drawingId = this.extractAttr(drawingElement, "r:id", { required: true })?.asString();
@@ -27825,6 +28043,7 @@ function createEmptySheet(sheetId, name) {
         rows: {},
         merges: [],
         conditionalFormats: [],
+        dataValidationRules: [],
         figures: [],
         tables: [],
         isVisible: true,
@@ -31388,6 +31607,10 @@ class Popover extends owl.Component {
             this.currentDisplayValue = newDisplay;
             if (!anchor)
                 return;
+            el.style.top = "";
+            el.style.left = "";
+            el.style["max-height"] = "";
+            el.style["max-width"] = "";
             const propsMaxSize = { width: this.props.maxWidth, height: this.props.maxHeight };
             let elDims = {
                 width: el.getBoundingClientRect().width,
@@ -40248,7 +40471,7 @@ dataValidationEvaluatorRegistry.add("dateIs", {
     name: _t("Date is"),
     getPreview: (criterion, getters) => {
         return criterion.dateValue === "exactDate"
-            ? _t("Date is %s", getDateCriterionFormattedValues(criterion, getters)[0])
+            ? _t("Date is %s", getDateCriterionFormattedValues(criterion.values, getters.getLocale())[0])
             : _t("Date is %s", DVTerms.DateIs[criterion.dateValue]);
     },
 });
@@ -40273,7 +40496,7 @@ dataValidationEvaluatorRegistry.add("dateIsBefore", {
     name: _t("Date is before"),
     getPreview: (criterion, getters) => {
         return criterion.dateValue === "exactDate"
-            ? _t("Date is before %s", getDateCriterionFormattedValues(criterion, getters)[0])
+            ? _t("Date is before %s", getDateCriterionFormattedValues(criterion.values, getters.getLocale())[0])
             : _t("Date is before %s", DVTerms.DateIsBefore[criterion.dateValue]);
     },
 });
@@ -40298,7 +40521,7 @@ dataValidationEvaluatorRegistry.add("dateIsOnOrBefore", {
     name: _t("Date is on or before"),
     getPreview: (criterion, getters) => {
         return criterion.dateValue === "exactDate"
-            ? _t("Date is on or before %s", getDateCriterionFormattedValues(criterion, getters)[0])
+            ? _t("Date is on or before %s", getDateCriterionFormattedValues(criterion.values, getters.getLocale())[0])
             : _t("Date is on or before %s", DVTerms.DateIsBefore[criterion.dateValue]);
     },
 });
@@ -40323,7 +40546,7 @@ dataValidationEvaluatorRegistry.add("dateIsAfter", {
     name: _t("Date is after"),
     getPreview: (criterion, getters) => {
         return criterion.dateValue === "exactDate"
-            ? _t("Date is after %s", getDateCriterionFormattedValues(criterion, getters)[0])
+            ? _t("Date is after %s", getDateCriterionFormattedValues(criterion.values, getters.getLocale())[0])
             : _t("Date is after %s", DVTerms.DateIsBefore[criterion.dateValue]);
     },
 });
@@ -40348,7 +40571,7 @@ dataValidationEvaluatorRegistry.add("dateIsOnOrAfter", {
     name: _t("Date is on or after"),
     getPreview: (criterion, getters) => {
         return criterion.dateValue === "exactDate"
-            ? _t("Date is on or after %s", getDateCriterionFormattedValues(criterion, getters)[0])
+            ? _t("Date is on or after %s", getDateCriterionFormattedValues(criterion.values, getters.getLocale())[0])
             : _t("Date is on or after %s", DVTerms.DateIsBefore[criterion.dateValue]);
     },
 });
@@ -40374,7 +40597,7 @@ dataValidationEvaluatorRegistry.add("dateIsBetween", {
     numberOfValues: () => 2,
     name: _t("Date is between"),
     getPreview: (criterion, getters) => {
-        const values = getDateCriterionFormattedValues(criterion, getters);
+        const values = getDateCriterionFormattedValues(criterion.values, getters.getLocale());
         return _t("Date is between %s and %s", values[0], values[1]);
     },
 });
@@ -40400,7 +40623,7 @@ dataValidationEvaluatorRegistry.add("dateIsNotBetween", {
     numberOfValues: () => 2,
     name: _t("Date is not between"),
     getPreview: (criterion, getters) => {
-        const values = getDateCriterionFormattedValues(criterion, getters);
+        const values = getDateCriterionFormattedValues(criterion.values, getters.getLocale());
         return _t("Date is not between %s and %s", values[0], values[1]);
     },
 });
@@ -40683,19 +40906,6 @@ function checkValueIsNumber(value) {
     const valueAsNumber = tryToNumber(value, DEFAULT_LOCALE);
     return valueAsNumber !== undefined;
 }
-function getDateCriterionFormattedValues(criterion, getters) {
-    const locale = getters.getLocale();
-    return criterion.values.map((valueStr) => {
-        if (valueStr.startsWith("=")) {
-            return valueStr;
-        }
-        const value = parseLiteral(valueStr, locale);
-        if (typeof value === "number") {
-            return formatValue(value, { format: locale.dateFormat, locale });
-        }
-        return "";
-    });
-}
 
 /** This component looks like a select input, but on click it opens a Menu with the items given as props instead of a dropdown */
 class SelectMenu extends owl.Component {
@@ -46398,7 +46608,7 @@ class GridComposer extends owl.Component {
             return;
         }
         const sheetId = this.env.model.getters.getActiveSheetId();
-        const zone = this.env.model.getters.getSelectedZone();
+        const zone = positionToZone(this.env.model.getters.getSelection().anchor.cell);
         const rect = this.env.model.getters.getVisibleRect(zone);
         if (!deepEquals(rect, this.rect) || sheetId !== this.composerStore.currentEditedCell.sheetId) {
             this.isCellReferenceVisible = true;
@@ -48232,13 +48442,23 @@ class GridRenderer {
     drawLayer(renderingContext, layer) {
         switch (layer) {
             case "Background":
-                const boxes = this.getGridBoxes();
-                this.drawBackground(renderingContext, boxes);
-                this.drawOverflowingCellBackground(renderingContext, boxes);
-                this.drawCellBackground(renderingContext, boxes);
-                this.drawBorders(renderingContext, boxes);
-                this.drawTexts(renderingContext, boxes);
-                this.drawIcon(renderingContext, boxes);
+                this.drawGlobalBackground(renderingContext);
+                for (const zone of this.getters.getAllActiveViewportsZones()) {
+                    const { ctx } = renderingContext;
+                    ctx.save();
+                    ctx.beginPath();
+                    const rect = this.getters.getVisibleRect(zone);
+                    ctx.rect(rect.x, rect.y, rect.width, rect.height);
+                    ctx.clip();
+                    const boxes = this.getGridBoxes(zone);
+                    this.drawBackground(renderingContext, boxes);
+                    this.drawOverflowingCellBackground(renderingContext, boxes);
+                    this.drawCellBackground(renderingContext, boxes);
+                    this.drawBorders(renderingContext, boxes);
+                    this.drawTexts(renderingContext, boxes);
+                    this.drawIcon(renderingContext, boxes);
+                    ctx.restore();
+                }
                 this.drawFrozenPanes(renderingContext);
                 break;
             case "Headers":
@@ -48249,12 +48469,15 @@ class GridRenderer {
                 break;
         }
     }
-    drawBackground(renderingContext, boxes) {
-        const { ctx, thinLineWidth } = renderingContext;
+    drawGlobalBackground(renderingContext) {
+        const { ctx } = renderingContext;
         const { width, height } = this.getters.getSheetViewDimensionWithHeaders();
         // white background
         ctx.fillStyle = "#ffffff";
         ctx.fillRect(0, 0, width + CANVAS_SHIFT, height + CANVAS_SHIFT);
+    }
+    drawBackground(renderingContext, boxes) {
+        const { ctx, thinLineWidth } = renderingContext;
         const areGridLinesVisible = !this.getters.isDashboard() &&
             this.getters.getGridLinesVisibility(this.getters.getActiveSheetId());
         const inset = areGridLinesVisible ? 0.1 * thinLineWidth : 0;
@@ -48685,7 +48908,7 @@ class GridRenderer {
         const position = { sheetId, col, row };
         const cell = this.getters.getEvaluatedCell(position);
         const showFormula = this.getters.shouldShowFormulas();
-        const { x, y, width, height } = this.getters.getVisibleRect(zone);
+        const { x, y, width, height } = this.getters.getRect(zone);
         const { verticalAlign } = this.getters.getCellStyle(position);
         const box = {
             x,
@@ -48803,12 +49026,16 @@ class GridRenderer {
         }
         return box;
     }
-    getGridBoxes() {
+    getGridBoxes(zone) {
         const boxes = [];
-        const visibleCols = this.getters.getSheetViewVisibleCols();
+        const visibleCols = this.getters
+            .getSheetViewVisibleCols()
+            .filter((col) => col >= zone.left && col <= zone.right);
         const left = visibleCols[0];
         const right = visibleCols[visibleCols.length - 1];
-        const visibleRows = this.getters.getSheetViewVisibleRows();
+        const visibleRows = this.getters
+            .getSheetViewVisibleRows()
+            .filter((row) => row >= zone.top && row <= zone.bottom);
         const top = visibleRows[0];
         const bottom = visibleRows[visibleRows.length - 1];
         const viewport = { left, right, top, bottom };
@@ -51158,7 +51385,7 @@ class CellPlugin extends CorePlugin {
     /*
      * Reconstructs the original formula string based on new dependencies
      */
-    getFormulaString(sheetId, tokens, dependencies, useFixedReference = false) {
+    getFormulaString(sheetId, tokens, dependencies, useBoundedReference = false) {
         if (!dependencies.length) {
             return concat(tokens.map((token) => token.value));
         }
@@ -51166,7 +51393,7 @@ class CellPlugin extends CorePlugin {
         return concat(tokens.map((token) => {
             if (token.type === "REFERENCE") {
                 const range = dependencies[rangeIndex++];
-                return this.getters.getRangeString(range, sheetId, { useFixedReference });
+                return this.getters.getRangeString(range, sheetId, { useBoundedReference });
             }
             return token.value;
         }));
@@ -51446,7 +51673,7 @@ class FormulaCellWithDependencies {
             if (token.type === "REFERENCE") {
                 const index = rangeIndex++;
                 return this.getRangeString(this.compiledFormula.dependencies[index], this.sheetId, {
-                    useFixedReference: true,
+                    useBoundedReference: true,
                 });
             }
             return token.value;
@@ -51783,7 +52010,7 @@ class ConditionalFormatPlugin extends CorePlugin {
         if (data.sheets) {
             for (let sheet of data.sheets) {
                 if (this.cfRules[sheet.id]) {
-                    sheet.conditionalFormats = this.cfRules[sheet.id].map((rule) => this.mapToConditionalFormat(sheet.id, rule, { useFixedReference: true }));
+                    sheet.conditionalFormats = this.cfRules[sheet.id].map((rule) => this.mapToConditionalFormat(sheet.id, rule, { useBoundedReference: true }));
                 }
             }
         }
@@ -51852,9 +52079,9 @@ class ConditionalFormatPlugin extends CorePlugin {
     // ---------------------------------------------------------------------------
     // Private
     // ---------------------------------------------------------------------------
-    mapToConditionalFormat(sheetId, cf, { useFixedReference } = { useFixedReference: false }) {
+    mapToConditionalFormat(sheetId, cf, { useBoundedReference } = { useBoundedReference: false }) {
         const ranges = cf.ranges.map((range) => {
-            return this.getters.getRangeString(range, sheetId, { useFixedReference });
+            return this.getters.getRangeString(range, sheetId, { useBoundedReference });
         });
         if (cf.rule.type !== "DataBarRule") {
             return {
@@ -51869,7 +52096,7 @@ class ConditionalFormatPlugin extends CorePlugin {
                 ...cf.rule,
                 rangeValues: cf.rule.rangeValues &&
                     this.getters.getRangeString(cf.rule.rangeValues, sheetId, {
-                        useFixedReference,
+                        useBoundedReference,
                     }),
             },
             ranges,
@@ -52292,6 +52519,30 @@ class DataValidationPlugin extends CorePlugin {
             }
         }
     }
+    exportForExcel(data) {
+        if (!data.sheets) {
+            return;
+        }
+        for (const sheet of data.sheets) {
+            sheet.dataValidationRules = [];
+            for (const rule of this.rules[sheet.id]) {
+                const excelRule = {
+                    ...deepCopy(rule),
+                    ranges: rule.ranges.map((range) => this.getters.getRangeString(range, sheet.id, { useBoundedReference: true })),
+                };
+                if (rule.criterion.type === "isValueInRange") {
+                    excelRule.criterion.values = rule.criterion.values.map((value) => {
+                        const range = this.getters.getRangeFromSheetXC(sheet.id, value);
+                        return this.getters.getRangeString(range, sheet.id, {
+                            useBoundedReference: true,
+                            useFixedReference: true,
+                        });
+                    });
+                }
+                sheet.dataValidationRules.push(excelRule);
+            }
+        }
+    }
     checkCriterionTypeIsValid(cmd) {
         return dataValidationEvaluatorRegistry.contains(cmd.rule.criterion.type)
             ? "Success" /* CommandResult.Success */
@@ -53702,9 +53953,10 @@ class RangeAdapter {
      * @param range the range (received from getRangeFromXC or getRangeFromZone)
      * @param forSheetId the id of the sheet where the range string is supposed to be used.
      * @param options
+     * @param options.useBoundedReference if true, the range will be returned with bounded row and column
      * @param options.useFixedReference if true, the range will be returned with fixed row and column
      */
-    getRangeString(range, forSheetId, options = { useFixedReference: false }) {
+    getRangeString(range, forSheetId, options = { useBoundedReference: false, useFixedReference: false }) {
         if (!range) {
             return CellErrorType.InvalidReference;
         }
@@ -53807,13 +54059,13 @@ class RangeAdapter {
     /**
      * Get a Xc string that represent a part of a range
      */
-    getRangePartString(range, part, options = { useFixedReference: false }) {
-        const colFixed = range.parts && range.parts[part]?.colFixed ? "$" : "";
+    getRangePartString(range, part, options = { useBoundedReference: false, useFixedReference: false }) {
+        const colFixed = range.parts[part]?.colFixed || options.useFixedReference ? "$" : "";
         const col = part === 0 ? numberToLetters(range.zone.left) : numberToLetters(range.zone.right);
-        const rowFixed = range.parts && range.parts[part]?.rowFixed ? "$" : "";
+        const rowFixed = range.parts[part]?.rowFixed || options.useFixedReference ? "$" : "";
         const row = part === 0 ? String(range.zone.top + 1) : String(range.zone.bottom + 1);
         let str = "";
-        if (range.isFullCol && !options.useFixedReference) {
+        if (range.isFullCol && !options.useBoundedReference) {
             if (part === 0 && range.unboundedZone.hasHeader) {
                 str = colFixed + col + rowFixed + row;
             }
@@ -53821,7 +54073,7 @@ class RangeAdapter {
                 str = colFixed + col;
             }
         }
-        else if (range.isFullRow && !options.useFixedReference) {
+        else if (range.isFullRow && !options.useBoundedReference) {
             if (part === 0 && range.unboundedZone.hasHeader) {
                 str = colFixed + col + rowFixed + row;
             }
@@ -54059,6 +54311,7 @@ class SheetPlugin extends CorePlugin {
                 formats: {},
                 borders: {},
                 conditionalFormats: [],
+                dataValidationRules: [],
                 figures: [],
                 tables: [],
                 areGridLinesVisible: sheet.areGridLinesVisible === undefined ? true : sheet.areGridLinesVisible,
@@ -61020,6 +61273,7 @@ class Session extends EventBus {
     waitingUndoRedoAck = false;
     isReplayingInitialRevisions = false;
     processedRevisions = new Set();
+    lastRevisionMessage = undefined;
     uuidGenerator = new UuidGenerator();
     lastLocalOperation;
     /**
@@ -61120,7 +61374,10 @@ class Session extends EventBus {
      * Notify the server that the user client left the collaborative session
      */
     async leave(data) {
-        if (data && Object.keys(this.clients).length === 1 && this.processedRevisions.size) {
+        if (data &&
+            Object.keys(this.clients).length === 1 &&
+            this.lastRevisionMessage &&
+            this.lastRevisionMessage?.type !== "SNAPSHOT_CREATED") {
             await this.snapshot(data());
         }
         delete this.clients[this.clientId];
@@ -61341,6 +61598,7 @@ class Session extends EventBus {
                 this.pendingMessages = this.pendingMessages.filter((msg) => msg.nextRevisionId !== message.nextRevisionId);
                 this.serverRevisionId = message.nextRevisionId;
                 this.processedRevisions.add(message.nextRevisionId);
+                this.lastRevisionMessage = message;
                 this.sendPendingMessage();
                 break;
         }
@@ -64542,8 +64800,12 @@ class GridSelectionPlugin extends UIPlugin {
             },
         ];
         handler.paste({ zones: pasteTarget, sheetId }, data, { isCutOperation: true });
+        const selection = pasteTarget[0];
+        const col = selection.left;
+        const row = selection.top;
+        this.setSelectionMixin({ zone: selection, cell: { col, row } }, [selection]);
         const toRemove = isBasedBefore ? cmd.elements.map((el) => el + thickness) : cmd.elements;
-        let currentIndex = cmd.base;
+        let currentIndex = isBasedBefore ? cmd.base : cmd.base + 1;
         for (const element of toRemove) {
             const size = this.getters.getHeaderSize(cmd.sheetId, cmd.dimension, element);
             this.dispatch("RESIZE_COLUMNS_ROWS", {
@@ -64826,22 +65088,33 @@ class InternalViewport {
     }
     /**
      *
-     * @param zone
-     * @returns Computes the absolute coordinate of a given zone inside the viewport
+     * Computes the visible coordinates & dimensions of a given zone inside the viewport
+     *
      */
-    getRect(zone) {
+    getVisibleRect(zone) {
         const targetZone = intersection(zone, this);
         if (targetZone) {
             const x = this.getters.getColRowOffset("COL", this.left, targetZone.left) + this.offsetCorrectionX;
             const y = this.getters.getColRowOffset("ROW", this.top, targetZone.top) + this.offsetCorrectionY;
             const width = Math.min(this.getters.getColRowOffset("COL", targetZone.left, targetZone.right + 1), this.viewportWidth);
             const height = Math.min(this.getters.getColRowOffset("ROW", targetZone.top, targetZone.bottom + 1), this.viewportHeight);
-            return {
-                x,
-                y,
-                width,
-                height,
-            };
+            return { x, y, width, height };
+        }
+        return undefined;
+    }
+    /**
+     *
+     * @returns Computes the absolute coordinates & dimensions of a given zone inside the viewport
+     *
+     */
+    getFullRect(zone) {
+        const targetZone = intersection(zone, this);
+        if (targetZone) {
+            const x = this.getters.getColRowOffset("COL", this.left, zone.left) + this.offsetCorrectionX;
+            const y = this.getters.getColRowOffset("ROW", this.top, zone.top) + this.offsetCorrectionY;
+            const width = this.getters.getColRowOffset("COL", zone.left, zone.right + 1);
+            const height = this.getters.getColRowOffset("ROW", zone.top, zone.bottom + 1);
+            return { x, y, width, height };
         }
         return undefined;
     }
@@ -65011,6 +65284,8 @@ class SheetViewPlugin extends UIPlugin {
         "isPositionVisible",
         "getColDimensionsInViewport",
         "getRowDimensionsInViewport",
+        "getAllActiveViewportsZones",
+        "getRect",
     ];
     viewports = {};
     /**
@@ -65397,16 +65672,27 @@ class SheetViewPlugin extends UIPlugin {
     getVisibleRectWithoutHeaders(zone) {
         const sheetId = this.getters.getActiveSheetId();
         const viewportRects = this.getSubViewports(sheetId)
-            .map((viewport) => viewport.getRect(zone))
+            .map((viewport) => viewport.getVisibleRect(zone))
             .filter(isDefined);
         if (viewportRects.length === 0) {
             return { x: 0, y: 0, width: 0, height: 0 };
         }
-        const x = Math.min(...viewportRects.map((rect) => rect.x));
-        const y = Math.min(...viewportRects.map((rect) => rect.y));
-        const width = Math.max(...viewportRects.map((rect) => rect.x + rect.width)) - x;
-        const height = Math.max(...viewportRects.map((rect) => rect.y + rect.height)) - y;
-        return { x, y, width, height };
+        return this.recomposeRect(viewportRects);
+    }
+    /**
+     * Computes the actual size and position (:Rect) of the zone on the canvas
+     * regardless of the viewport dimensions.
+     */
+    getRect(zone) {
+        const sheetId = this.getters.getActiveSheetId();
+        const viewportRects = this.getSubViewports(sheetId)
+            .map((viewport) => viewport.getFullRect(zone))
+            .filter(isDefined);
+        if (viewportRects.length === 0) {
+            return { x: 0, y: 0, width: 0, height: 0 };
+        }
+        const rect = this.recomposeRect(viewportRects);
+        return { ...rect, x: rect.x + this.gridOffsetX, y: rect.y + this.gridOffsetY };
     }
     /**
      * Returns the position of the MainViewport relatively to the start of the grid (without headers)
@@ -65450,6 +65736,10 @@ class SheetViewPlugin extends UIPlugin {
             end: start + (isRowHidden ? 0 : size),
         };
     }
+    getAllActiveViewportsZones() {
+        const sheetId = this.getters.getActiveSheetId();
+        return this.getSubViewports(sheetId);
+    }
     // ---------------------------------------------------------------------------
     // Private
     // ---------------------------------------------------------------------------
@@ -65640,6 +65930,13 @@ class SheetViewPlugin extends UIPlugin {
         const height = this.sheetViewHeight + this.gridOffsetY;
         return { xRatio: offsetCorrectionX / width, yRatio: offsetCorrectionY / height };
     }
+    recomposeRect(viewportRects) {
+        const x = Math.min(...viewportRects.map((rect) => rect.x));
+        const y = Math.min(...viewportRects.map((rect) => rect.y));
+        const width = Math.max(...viewportRects.map((rect) => rect.x + rect.width)) - x;
+        const height = Math.max(...viewportRects.map((rect) => rect.y + rect.height)) - y;
+        return { x, y, width, height };
+    }
 }
 
 class HeaderPositionsUIPlugin extends UIPlugin {
@@ -70945,6 +71242,124 @@ function getExcelThresholdType(type, position) {
     }
 }
 
+function addDataValidationRules(dataValidationRules) {
+    const dvRulesCount = dataValidationRules.length;
+    if (dvRulesCount === 0) {
+        return [];
+    }
+    const dvNodes = [new XMLString(`<dataValidations count="${dvRulesCount}">`)];
+    for (const dvRule of dataValidationRules) {
+        switch (dvRule.criterion.type) {
+            case "dateIs":
+            case "dateIsBefore":
+            case "dateIsOnOrBefore":
+            case "dateIsAfter":
+            case "dateIsOnOrAfter":
+            case "dateIsBetween":
+            case "dateIsNotBetween":
+                dvNodes.push(addDateRule(dvRule));
+                break;
+            case "isEqual":
+            case "isNotEqual":
+            case "isGreaterThan":
+            case "isGreaterOrEqualTo":
+            case "isLessThan":
+            case "isLessOrEqualTo":
+            case "isBetween":
+            case "isNotBetween":
+                dvNodes.push(addDecimalRule(dvRule));
+                break;
+            case "isValueInRange":
+            case "isValueInList":
+                dvNodes.push(addListRule(dvRule));
+                break;
+            case "customFormula":
+                dvNodes.push(addCustomFormulaRule(dvRule));
+                break;
+            default:
+                console.warn(`Data validation ${dvRule.criterion.type} is not supported in xlsx.`);
+                break;
+        }
+    }
+    dvNodes.push(new XMLString("</dataValidations>"));
+    return dvNodes;
+}
+function addDateRule(dvRule) {
+    const rule = dvRule.criterion;
+    const formula1 = adaptFormulaToExcel(rule.values[0]);
+    const formula2 = rule.values[1] ? adaptFormulaToExcel(rule.values[1]) : undefined;
+    const operator = convertDateCriterionTypeToExcelOperator(dvRule.criterion.type);
+    const attributes = commonDataValidationAttributes(dvRule);
+    attributes.push(["type", "date"], ["operator", operator]);
+    if (formula2) {
+        return escapeXml /*xml*/ `
+      <dataValidation ${formatAttributes(attributes)}>
+        <formula1>${toNumber(formula1, DEFAULT_LOCALE)}</formula1>
+        <formula2>${toNumber(formula2, DEFAULT_LOCALE)}</formula2>
+      </dataValidation>
+    `;
+    }
+    return escapeXml /*xml*/ `
+    <dataValidation ${formatAttributes(attributes)}>
+      <formula1>${toNumber(formula1, DEFAULT_LOCALE)}</formula1>
+    </dataValidation>
+  `;
+}
+function addDecimalRule(dvRule) {
+    const rule = dvRule.criterion;
+    const formula1 = adaptFormulaToExcel(rule.values[0]);
+    const formula2 = rule.values[1] ? adaptFormulaToExcel(rule.values[1]) : undefined;
+    const operator = convertDecimalCriterionTypeToExcelOperator(dvRule.criterion.type);
+    const attributes = commonDataValidationAttributes(dvRule);
+    attributes.push(["type", "decimal"], ["operator", operator]);
+    if (formula2) {
+        return escapeXml /*xml*/ `
+      <dataValidation ${formatAttributes(attributes)}>
+        <formula1>${formula1}</formula1>
+        <formula2>${formula2}</formula2>
+      </dataValidation>
+    `;
+    }
+    return escapeXml /*xml*/ `
+    <dataValidation ${formatAttributes(attributes)}>
+      <formula1>${formula1}</formula1>
+    </dataValidation>
+  `;
+}
+function addListRule(dvRule) {
+    const rule = dvRule.criterion;
+    const formula1 = dvRule.criterion.type === "isValueInRange"
+        ? adaptFormulaToExcel(rule.values[0])
+        : `"${rule.values.join(",")}"`;
+    const attributes = commonDataValidationAttributes(dvRule);
+    attributes.push(["type", "list"]);
+    return escapeXml /*xml*/ `
+    <dataValidation ${formatAttributes(attributes)}>
+      <formula1>${formula1}</formula1>
+    </dataValidation>
+  `;
+}
+function addCustomFormulaRule(dvRule) {
+    const rule = dvRule.criterion;
+    const formula1 = adaptFormulaToExcel(rule.values[0]);
+    const attributes = commonDataValidationAttributes(dvRule);
+    attributes.push(["type", "custom"]);
+    return escapeXml /*xml*/ `
+    <dataValidation ${formatAttributes(attributes)}>
+      <formula1>${formula1}</formula1>
+    </dataValidation>
+  `;
+}
+function commonDataValidationAttributes(dvRule) {
+    return [
+        ["allowBlank", "1"],
+        ["showInputMessage", "1"],
+        ["showErrorMessage", "1"],
+        ["errorStyle", !dvRule.isBlocking ? "warning" : ""],
+        ["sqref", dvRule.ranges.join(" ")],
+    ];
+}
+
 function createDrawing(drawingRelIds, sheet, figures) {
     const namespaces = [
         ["xmlns:xdr", NAMESPACE.drawing],
@@ -71723,6 +72138,7 @@ function createWorksheets(data, construct) {
         ${addRows(construct, data, sheet)}
         ${addMerges(sheet.merges)}
         ${joinXmlNodes(addConditionalFormatting(construct.dxfs, sheet.conditionalFormats))}
+        ${joinXmlNodes(addDataValidationRules(sheet.dataValidationRules))}
         ${addHyperlinks(construct, data, sheetIndex)}
         ${drawingNode}
         ${tablesNode}
@@ -72674,6 +73090,6 @@ exports.tokenColors = tokenColors;
 exports.tokenize = tokenize;
 
 
-__info__.version = "18.0.10";
-__info__.date = "2025-01-15T08:05:47.616Z";
-__info__.hash = "94c45c7";
+__info__.version = "18.0.12";
+__info__.date = "2025-01-29T06:24:22.122Z";
+__info__.hash = "a881cff";