@odoo/o-spreadsheet 18.5.0-alpha.3 → 18.5.0-alpha.5

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 18.5.0-alpha.3
- * @date 2025-07-28T13:43:05.981Z
- * @hash 53dfee8
+ * @version 18.5.0-alpha.5
+ * @date 2025-08-04T06:53:29.412Z
+ * @hash 71c9a36
  */
 
 (function (exports, owl) {
@@ -1057,16 +1057,21 @@
       "#001f3f",
   ];
   /*
-   * transform a color number (R * 256^2 + G * 256 + B) into classic hex6 value
+   * transform a color number (R * 256^2 + G * 256 + B) into classic hex (+alpha) value
    * */
-  function colorNumberString(color) {
-      return toHex(color.toString(16).padStart(6, "0"));
+  function colorNumberToHex(color, alpha = 1) {
+      const alphaHex = alpha !== 1
+          ? Math.round(alpha * 255)
+              .toString(16)
+              .padStart(2, "0")
+          : "";
+      return toHex(color.toString(16).padStart(6, "0")) + alphaHex;
   }
   function colorToNumber(color) {
       if (typeof color === "number") {
           return color;
       }
-      return Number.parseInt(toHex(color).slice(1), 16);
+      return Number.parseInt(toHex(color).slice(1, 7), 16);
   }
   /**
    * Converts any CSS color value to a standardized hex6 value.
@@ -1325,6 +1330,12 @@
   function hexToHSLA(hex) {
       return rgbaToHSLA(colorToRGBA(hex));
   }
+  function colorOrNumberToRGBA(color) {
+      if (typeof color === "number") {
+          return colorToRGBA(colorNumberToHex(color));
+      }
+      return colorToRGBA(color);
+  }
   /**
    * Will compare two color strings
    * A tolerance can be provided to account for small differences that could
@@ -1606,6 +1617,8 @@
       const sortedColorScalePoints = [...colorScalePoints.sort((a, b) => a.value - b.value)];
       const thresholds = [];
       for (let i = 1; i < sortedColorScalePoints.length; i++) {
+          const minColorAlpha = colorOrNumberToRGBA(sortedColorScalePoints[i - 1].color).a;
+          const maxColorAlpha = colorOrNumberToRGBA(sortedColorScalePoints[i].color).a;
           const minColor = colorToNumber(sortedColorScalePoints[i - 1].color);
           const maxColor = colorToNumber(sortedColorScalePoints[i].color);
           thresholds.push({
@@ -1613,19 +1626,21 @@
               max: sortedColorScalePoints[i].value,
               minColor,
               maxColor,
+              minColorAlpha: minColorAlpha,
+              maxColorAlpha: maxColorAlpha,
               colorDiff: computeColorDiffUnits(sortedColorScalePoints[i - 1].value, sortedColorScalePoints[i].value, minColor, maxColor),
           });
       }
       return (value) => {
           if (value < thresholds[0].min) {
-              return colorNumberString(thresholds[0].minColor);
+              return colorNumberToHex(thresholds[0].minColor, thresholds[0].minColorAlpha);
           }
           for (const threshold of thresholds) {
               if (value >= threshold.min && value <= threshold.max) {
-                  return colorNumberString(colorCell(value, threshold.min, threshold.minColor, threshold.colorDiff));
+                  return colorNumberToHex(colorCell(value, threshold.min, threshold.minColor, threshold.colorDiff), threshold.maxColorAlpha);
               }
           }
-          return colorNumberString(thresholds[thresholds.length - 1].maxColor);
+          return colorNumberToHex(thresholds[thresholds.length - 1].maxColor, thresholds[thresholds.length - 1].maxColorAlpha);
       };
   }
   function computeColorDiffUnits(minValue, maxValue, minColor, maxColor) {
@@ -8639,12 +8654,12 @@
       avg: _t("Average"),
       sum: _t("Sum"),
   };
-  const NUMBER_CHAR_AGGREGATORS = ["max", "min", "avg", "sum", "count_distinct", "count"];
+  const DEFAULT_AGGREGATORS = ["max", "min", "avg", "sum", "count_distinct", "count"];
   const AGGREGATORS_BY_FIELD_TYPE = {
-      integer: NUMBER_CHAR_AGGREGATORS,
-      char: NUMBER_CHAR_AGGREGATORS,
+      integer: DEFAULT_AGGREGATORS,
+      char: DEFAULT_AGGREGATORS,
+      datetime: DEFAULT_AGGREGATORS,
       boolean: ["count_distinct", "count", "bool_and", "bool_or"],
-      datetime: ["max", "min", "count_distinct", "count"],
   };
   const AGGREGATORS = {};
   for (const type in AGGREGATORS_BY_FIELD_TYPE) {
@@ -20477,6 +20492,54 @@ stores.inject(MyMetaStore, storeInstance);
       },
       isExported: true,
   };
+  const REGEXEXTRACT_DEFAULT_MODE = 0;
+  const REGEXEXTRACT_DEFAULT_CASE_SENSITIVITY = 0;
+  // -----------------------------------------------------------------------------
+  // REGEXEXTRACT
+  // -----------------------------------------------------------------------------
+  const REGEXEXTRACT = {
+      description: _t("Extract text from a string based on the supplied regular expression."),
+      args: [
+          arg("text (string)", _t("The string on which you want to extract text.")),
+          arg("pattern (string)", _t("The regular expression pattern to match against the text.")),
+          arg(`return_mode (number, default=${REGEXEXTRACT_DEFAULT_MODE})`, _t("0 = first match, 1 = all matches as an array, 2 = capturing groups from the first match as an array.")),
+          arg(`case_sensitivity (number, default=${REGEXEXTRACT_DEFAULT_CASE_SENSITIVITY})`, _t("0 = case-sensitive, 1 = case-insensitive.")),
+      ],
+      compute: function (text, pattern, return_mode = { value: REGEXEXTRACT_DEFAULT_MODE }, newText = { value: REGEXEXTRACT_DEFAULT_CASE_SENSITIVITY }) {
+          const _text = toString(text);
+          const _pattern = toString(pattern);
+          const _returnMode = toNumber(return_mode, this.locale);
+          const _caseSensitivity = toNumber(newText, this.locale);
+          if (_text === "" || _pattern === "") {
+              return { value: "" };
+          }
+          if (_returnMode < 0 || _returnMode > 2) {
+              return new EvaluationError(_t("The return_mode (%s) must be 0, 1 or 2.", _returnMode));
+          }
+          if (_caseSensitivity !== 0 && _caseSensitivity !== 1) {
+              return new EvaluationError(_t("The case_sensitivity (%s) must be 0 or 1.", _caseSensitivity));
+          }
+          const flags = _caseSensitivity === 1 ? "gi" : "g";
+          const regex = new RegExp(_pattern, flags);
+          const matches = [..._text.matchAll(regex)];
+          if (matches.length === 0) {
+              return { value: CellErrorType.NotAvailable, message: _t("No matches found.") };
+          }
+          if (_returnMode === 0) {
+              return matches[0][0];
+          }
+          else if (_returnMode === 1) {
+              return matches.map((match) => [match[0]]);
+          }
+          else {
+              if (matches[0].length < 2) {
+                  return new EvaluationError(_t("No capturing groups found."));
+              }
+              return matches[0].slice(1).map((s) => [s]);
+          }
+      },
+      isExported: true,
+  };
   // -----------------------------------------------------------------------------
   // REPLACE
   // -----------------------------------------------------------------------------
@@ -20753,6 +20816,105 @@ stores.inject(MyMetaStore, storeInstance);
       },
       isExported: true,
   };
+  // -----------------------------------------------------------------------------
+  // TEXTAFTER
+  // -----------------------------------------------------------------------------
+  const TEXT_FN_DEFAULT_INSTANCE = 1;
+  const TEXT_FN_DEFAULT_MATCH_MODE = 0;
+  const TEXT_FN_DEFAULT_MATCH_END = 0;
+  const TEXTAFTER = {
+      description: _t("Returns text that occurs after a given substring or delimiter."),
+      args: [
+          arg("text (string)", _t("The source text.")),
+          arg("delimiter (string)", _t("The substring after which text will be returned.")),
+          arg(`instance_num (number, default=${TEXT_FN_DEFAULT_INSTANCE})`, _t("The desired instance of the delimiter after which we extract the text. A negative number searches from the end.")),
+          arg(`match_mode (number, default=${TEXT_FN_DEFAULT_MATCH_MODE})`, _t("0 = case-sensitive, 1 = case-insensitive.")),
+          arg(`match_end (number, default=${TEXT_FN_DEFAULT_MATCH_END}))`, _t("Whether to treat the end of text as a delimiter.")),
+          arg(`if_not_found (string, default="${CellErrorType.NotAvailable}")`, _t("Value to return if the delimiter is not found.")),
+      ],
+      compute: function (text, delimiter, matchIndex = { value: TEXT_FN_DEFAULT_INSTANCE }, matchMode = { value: TEXT_FN_DEFAULT_MATCH_MODE }, matchEnd = { value: TEXT_FN_DEFAULT_MATCH_END }, ifNotFound = new NotAvailableError()) {
+          const _text = toString(text);
+          const _matchIndex = toNumber(matchIndex, this.locale);
+          const _matchMode = toNumber(matchMode, this.locale);
+          const _matchEnd = toNumber(matchEnd, this.locale);
+          if (_matchIndex === 0) {
+              return new EvaluationError(_t("The instance_num (%s) must not be zero.", _matchIndex));
+          }
+          if (_matchMode !== 0 && _matchMode !== 1) {
+              return new EvaluationError(_t("match_mode should have a value of 0 or 1."));
+          }
+          if (_matchEnd !== 0 && _matchEnd !== 1) {
+              return new EvaluationError(_t("match_end should have a value of 0 or 1."));
+          }
+          const _delimiter = toString(delimiter);
+          if (_delimiter === "") {
+              return Math.sign(_matchIndex) > 0 ? { value: _text } : { value: "" };
+          }
+          const flags = _matchMode === 1 ? "gi" : "g";
+          const pattern = escapeRegExp(_delimiter);
+          const regexp = new RegExp(pattern, flags);
+          let matchIndices = [..._text.matchAll(regexp)].map((match) => match.index + pattern.length);
+          if (_matchIndex < 0) {
+              matchIndices = matchIndices.reverse();
+          }
+          // If _matchEnd, we act like the text is appended by the delimiter (or prepended if negative index)
+          if (_matchEnd && Math.abs(_matchIndex) === matchIndices.length + 1) {
+              return Math.sign(_matchIndex) > 0 ? { value: "" } : { value: _text };
+          }
+          const targetIndex = matchIndices[Math.abs(_matchIndex) - 1];
+          return targetIndex === undefined ? ifNotFound : { value: _text.substring(targetIndex) };
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
+  // TEXTBEFORE
+  // -----------------------------------------------------------------------------
+  const TEXTBEFORE = {
+      description: _t("Returns text that occurs before a given substring or delimiter."),
+      args: [
+          arg("text (string)", _t("The source text.")),
+          arg("delimiter (string)", _t("The substring after which text will be returned.")),
+          arg(`instance_num (number, default=${TEXT_FN_DEFAULT_INSTANCE})`, _t("The desired instance of the delimiter before which we extract the text. A negative number searches from the end.")),
+          arg(`match_mode (number, default=${TEXT_FN_DEFAULT_MATCH_MODE})`, _t("0 = case-sensitive, 1 = case-insensitive.")),
+          arg(`match_end (number, default=${TEXT_FN_DEFAULT_MATCH_END}))`, _t("Whether to match a delimiter against the end of the text.")),
+          arg(`if_not_found (string, default="${CellErrorType.NotAvailable}")`, _t("Value to return if the delimiter is not found.")),
+      ],
+      compute: function (text, delimiter, matchIndex = { value: TEXT_FN_DEFAULT_INSTANCE }, matchMode = { value: TEXT_FN_DEFAULT_MATCH_MODE }, matchEnd = { value: TEXT_FN_DEFAULT_MATCH_END }, ifNotFound = new NotAvailableError()) {
+          const _text = toString(text);
+          const _matchIndex = toNumber(matchIndex, this.locale);
+          const _matchMode = toNumber(matchMode, this.locale);
+          const _matchEnd = toNumber(matchEnd, this.locale);
+          if (_matchIndex === 0) {
+              return new EvaluationError(_t("The instance_num (%s) must not be zero.", _matchIndex));
+          }
+          if (_matchMode !== 0 && _matchMode !== 1) {
+              return new EvaluationError(_t("match_mode should have a value of 0 or 1."));
+          }
+          if (_matchEnd !== 0 && _matchEnd !== 1) {
+              return new EvaluationError(_t("match_end should have a value of 0 or 1."));
+          }
+          const _delimiter = toString(delimiter);
+          if (_delimiter === "") {
+              return Math.sign(_matchIndex) > 0 ? { value: "" } : { value: _text };
+          }
+          const flags = _matchMode === 1 ? "gi" : "g";
+          const pattern = escapeRegExp(_delimiter);
+          const regexp = new RegExp(pattern, flags);
+          let matchIndices = [..._text.matchAll(regexp)].map((match) => match.index + pattern.length);
+          if (_matchIndex < 0) {
+              matchIndices = matchIndices.reverse();
+          }
+          // If _matchEnd, we act like the text is appended by the delimiter (or prepended if negative index)
+          if (_matchEnd && Math.abs(_matchIndex) === matchIndices.length + 1) {
+              return Math.sign(_matchIndex) > 0 ? { value: _text } : { value: "" };
+          }
+          const targetIndex = matchIndices[Math.abs(_matchIndex) - 1];
+          return targetIndex === undefined
+              ? ifNotFound
+              : { value: _text.substring(0, targetIndex - _delimiter.length) };
+      },
+      isExported: true,
+  };
 
   var text = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -20767,12 +20929,15 @@ stores.inject(MyMetaStore, storeInstance);
     LOWER: LOWER,
     MID: MID,
     PROPER: PROPER,
+    REGEXEXTRACT: REGEXEXTRACT,
     REPLACE: REPLACE,
     RIGHT: RIGHT,
     SEARCH: SEARCH,
     SPLIT: SPLIT,
     SUBSTITUTE: SUBSTITUTE,
     TEXT: TEXT,
+    TEXTAFTER: TEXTAFTER,
+    TEXTBEFORE: TEXTBEFORE,
     TEXTJOIN: TEXTJOIN,
     TEXTSPLIT: TEXTSPLIT,
     TRIM: TRIM,
@@ -22776,6 +22941,7 @@ stores.inject(MyMetaStore, storeInstance);
               this.animationStore = useStore(ChartAnimationStore);
           }
           owl.onMounted(() => {
+              registerChartJSExtensions();
               const runtime = this.chartRuntime;
               this.currentRuntime = runtime;
               // Note: chartJS modify the runtime in place, so it's important to give it a copy
@@ -30516,28 +30682,17 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  class ChartDashboardMenu extends owl.Component {
-      static template = "spreadsheet.ChartDashboardMenu";
-      static components = { MenuPopover };
-      static props = { figureUI: Object };
+  class ChartDashboardMenuStore extends SpreadsheetStore {
+      chartId;
+      mutators = ["reset"];
       originalChartDefinition;
-      fullScreenFigureStore;
-      menuState = owl.useState({ isOpen: false, anchorRect: null, menuItems: [] });
-      setup() {
-          super.setup();
-          this.fullScreenFigureStore = useStore(FullScreenChartStore);
-          this.originalChartDefinition = this.env.model.getters.getChartDefinition(this.props.figureUI.id);
-          owl.onWillUpdateProps(({ figureUI }) => {
-              if (figureUI.id !== this.props.figureUI.id) {
-                  this.originalChartDefinition = this.env.model.getters.getChartDefinition(figureUI.id);
-              }
-          });
-      }
-      getMenuItems() {
-          return [this.fullScreenMenuItem, ...this.changeChartTypeMenuItems].filter(isDefined);
+      constructor(get, chartId) {
+          super(get);
+          this.chartId = chartId;
+          this.originalChartDefinition = this.getters.getChartDefinition(this.chartId);
       }
       get changeChartTypeMenuItems() {
-          const definition = this.env.model.getters.getChartDefinition(this.props.figureUI.id);
+          const definition = this.getters.getChartDefinition(this.chartId);
           if (!["line", "bar", "pie"].includes(definition.type)) {
               return [];
           }
@@ -30546,27 +30701,19 @@ stores.inject(MyMetaStore, storeInstance);
               return {
                   id: item.chartType,
                   label: item.displayName,
-                  onClick: () => this.onTypeChange(item.chartType),
-                  isSelected: item.chartType === this.selectedChartType,
+                  onClick: () => this.updateType(item.chartType),
+                  isSelected: item.chartType === this.getters.getChartDefinition(this.chartId).type,
                   iconClass: this.getIconClasses(item.chartType),
               };
           });
       }
-      getIconClasses(type) {
-          if (type.includes("bar")) {
-              return "fa fa-bar-chart";
-          }
-          if (type.includes("line")) {
-              return "fa fa-line-chart";
-          }
-          if (type.includes("pie")) {
-              return "fa fa-pie-chart";
-          }
-          return "";
+      reset(chartId) {
+          this.chartId = chartId;
+          this.originalChartDefinition = this.getters.getChartDefinition(chartId);
       }
-      onTypeChange(type) {
-          const figureId = this.props.figureUI.id;
-          const currentDefinition = this.env.model.getters.getChartDefinition(figureId);
+      updateType(type) {
+          const figureId = this.chartId;
+          const currentDefinition = this.getters.getChartDefinition(figureId);
           if (currentDefinition.type === type) {
               return;
           }
@@ -30577,7 +30724,7 @@ stores.inject(MyMetaStore, storeInstance);
           else {
               const newChartInfo = chartSubtypeRegistry.get(type);
               const ChartClass = chartRegistry.get(newChartInfo.chartType);
-              const chartCreationContext = this.env.model.getters.getContextCreationChart(figureId);
+              const chartCreationContext = this.getters.getContextCreationChart(figureId);
               if (!chartCreationContext)
                   return;
               definition = {
@@ -30585,14 +30732,45 @@ stores.inject(MyMetaStore, storeInstance);
                   ...newChartInfo.subtypeDefinition,
               };
           }
-          this.env.model.dispatch("UPDATE_CHART", {
+          this.model.dispatch("UPDATE_CHART", {
               definition,
               figureId,
-              sheetId: this.env.model.getters.getActiveSheetId(),
+              sheetId: this.getters.getActiveSheetId(),
           });
       }
-      get selectedChartType() {
-          return this.env.model.getters.getChartDefinition(this.props.figureUI.id).type;
+      getIconClasses(type) {
+          if (type.includes("bar")) {
+              return "fa fa-bar-chart";
+          }
+          if (type.includes("line")) {
+              return "fa fa-line-chart";
+          }
+          if (type.includes("pie")) {
+              return "fa fa-pie-chart";
+          }
+          return "";
+      }
+  }
+
+  class ChartDashboardMenu extends owl.Component {
+      static template = "o-spreadsheet-ChartDashboardMenu";
+      static components = { MenuPopover };
+      static props = { figureUI: Object };
+      fullScreenFigureStore;
+      store;
+      menuState = owl.useState({ isOpen: false, anchorRect: null, menuItems: [] });
+      setup() {
+          super.setup();
+          this.store = useLocalStore(ChartDashboardMenuStore, this.props.figureUI.id);
+          this.fullScreenFigureStore = useStore(FullScreenChartStore);
+          owl.onWillUpdateProps(({ figureUI }) => {
+              if (figureUI.id !== this.props.figureUI.id) {
+                  this.store.reset(figureUI.id);
+              }
+          });
+      }
+      getMenuItems() {
+          return [this.fullScreenMenuItem, ...this.store.changeChartTypeMenuItems].filter(isDefined);
       }
       get backgroundColor() {
           const color = this.env.model.getters.getChartDefinition(this.props.figureUI.id).background;
@@ -31734,7 +31912,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const criterionValues = getters.getDataValidationRangeValues(sheetId, criterion);
           return criterionValues
-              .map((value) => value.toLowerCase())
+              .map((value) => value.value.toLowerCase())
               .includes(value.toString().toLowerCase());
       },
       getErrorString: (criterion) => _t("The value must be a value in the range %s", String(criterion.values[0])),
@@ -32166,40 +32344,6 @@ stores.inject(MyMetaStore, storeInstance);
       return sameColor && sameClass && sameContent;
   }
 
-  // -----------------------------------------------------------------------------
-  // Formula Assistant component
-  // -----------------------------------------------------------------------------
-  css /* scss */ `
-  .o-formula-assistant {
-    background: #ffffff;
-    .o-formula-assistant-head {
-      background-color: #f2f2f2;
-      padding: 10px;
-    }
-    .collapsed {
-      transform: rotate(180deg);
-    }
-    .o-formula-assistant-core {
-      border-bottom: 1px solid gray;
-    }
-    .o-formula-assistant-arg-description {
-      font-size: 85%;
-    }
-    .o-formula-assistant-focus {
-      div:first-child,
-      span {
-        color: ${COMPOSER_ASSISTANT_COLOR};
-        text-shadow: 0px 0px 1px ${COMPOSER_ASSISTANT_COLOR};
-      }
-      div:last-child {
-        color: black;
-      }
-    }
-    .o-formula-assistant-gray {
-      color: gray;
-    }
-  }
-`;
   class FunctionDescriptionProvider extends owl.Component {
       static template = "o-spreadsheet-FunctionDescriptionProvider";
       static props = {
@@ -51912,16 +52056,16 @@ stores.inject(MyMetaStore, storeInstance);
               return cssPropertiesToCss(cellStyleToCss(rule.style));
           }
           else if (rule.type === "ColorScaleRule") {
-              const minColor = colorNumberString(rule.minimum.color);
-              const midColor = rule.midpoint ? colorNumberString(rule.midpoint.color) : null;
-              const maxColor = colorNumberString(rule.maximum.color);
+              const minColor = colorNumberToHex(rule.minimum.color);
+              const midColor = rule.midpoint ? colorNumberToHex(rule.midpoint.color) : null;
+              const maxColor = colorNumberToHex(rule.maximum.color);
               const baseString = "background-image: linear-gradient(to right, ";
               return midColor
                   ? baseString + minColor + ", " + midColor + ", " + maxColor + ")"
                   : baseString + minColor + ", " + maxColor + ")";
           }
           else if (rule.type === "DataBarRule") {
-              const color = colorNumberString(rule.color);
+              const color = colorNumberToHex(rule.color);
               return `background-image: linear-gradient(to right, ${color} 50%, white 50%)`;
           }
           return "";
@@ -52111,7 +52255,8 @@ stores.inject(MyMetaStore, storeInstance);
       static props = {
           editedCf: Object,
           onCancel: Function,
-          onSave: Function,
+          onExit: Function,
+          isNewCf: Boolean,
       };
       static components = {
           SelectionInput,
@@ -52128,7 +52273,7 @@ stores.inject(MyMetaStore, storeInstance);
       icons = ICONS;
       iconSets = ICON_SETS;
       getTextDecoration = getTextDecoration;
-      colorNumberString = colorNumberString;
+      colorNumberToHex = colorNumberToHex;
       state;
       setup() {
           this.state = owl.useState({
@@ -52136,6 +52281,7 @@ stores.inject(MyMetaStore, storeInstance);
               currentCFType: this.props.editedCf.rule.type,
               ranges: this.props.editedCf.ranges,
               rules: this.getDefaultRules(),
+              hasEditedCf: this.props.isNewCf,
           });
           switch (this.props.editedCf.rule.type) {
               case "CellIsRule":
@@ -52187,6 +52333,9 @@ stores.inject(MyMetaStore, storeInstance);
               ranges: ranges.map((xc) => this.env.model.getters.getRangeDataFromXc(sheetId, xc)),
               sheetId,
           });
+          if (result.isSuccessful) {
+              this.state.hasEditedCf = true;
+          }
           const reasons = result.reasons.filter((r) => r !== "NoChanges" /* CommandResult.NoChanges */);
           if (!newCf.suppressErrors) {
               this.state.errors = reasons;
@@ -52208,7 +52357,15 @@ stores.inject(MyMetaStore, storeInstance);
       onSave() {
           const result = this.updateConditionalFormat({});
           if (result.length === 0) {
-              this.props.onSave();
+              this.props.onExit();
+          }
+      }
+      onCancel() {
+          if (this.state.hasEditedCf) {
+              this.props.onCancel();
+          }
+          else {
+              this.props.onExit();
           }
       }
       getDefaultRules() {
@@ -52367,9 +52524,9 @@ stores.inject(MyMetaStore, storeInstance);
       }
       getPreviewGradient() {
           const rule = this.state.rules.colorScale;
-          const minColor = colorNumberString(rule.minimum.color);
-          const midColor = colorNumberString(rule.midpoint?.color || DEFAULT_COLOR_SCALE_MIDPOINT_COLOR);
-          const maxColor = colorNumberString(rule.maximum.color);
+          const minColor = colorNumberToHex(rule.minimum.color);
+          const midColor = colorNumberToHex(rule.midpoint?.color || DEFAULT_COLOR_SCALE_MIDPOINT_COLOR);
+          const maxColor = colorNumberToHex(rule.maximum.color);
           const baseString = "background-image: linear-gradient(to right, ";
           return rule.midpoint === undefined
               ? baseString + minColor + ", " + maxColor + ")"
@@ -52377,8 +52534,8 @@ stores.inject(MyMetaStore, storeInstance);
       }
       getThresholdColor(threshold) {
           return threshold
-              ? colorNumberString(threshold.color)
-              : colorNumberString(DEFAULT_COLOR_SCALE_MIDPOINT_COLOR);
+              ? colorNumberToHex(threshold.color)
+              : colorNumberToHex(DEFAULT_COLOR_SCALE_MIDPOINT_COLOR);
       }
       onMidpointChange(ev) {
           const type = ev.target.value;
@@ -66602,9 +66759,9 @@ stores.inject(MyMetaStore, storeInstance);
                   formatColors.push(rule.style.fillColor);
               }
               else if (rule.type === "ColorScaleRule") {
-                  formatColors.push(colorNumberString(rule.minimum.color));
-                  formatColors.push(rule.midpoint ? colorNumberString(rule.midpoint.color) : undefined);
-                  formatColors.push(colorNumberString(rule.maximum.color));
+                  formatColors.push(colorNumberToHex(rule.minimum.color));
+                  formatColors.push(rule.midpoint ? colorNumberToHex(rule.midpoint.color) : undefined);
+                  formatColors.push(colorNumberToHex(rule.maximum.color));
               }
           }
           return formatColors.filter(isDefined);
@@ -66975,7 +67132,7 @@ stores.inject(MyMetaStore, storeInstance);
                   if (!computedDataBars[col])
                       computedDataBars[col] = [];
                   computedDataBars[col][row] = {
-                      color: colorNumberString(color),
+                      color: colorNumberToHex(color),
                       percentage: (cell.value * 100) / max,
                   };
               }
@@ -67104,8 +67261,16 @@ stores.inject(MyMetaStore, storeInstance);
       }
       getDataValidationRangeValues(sheetId, criterion) {
           const range = this.getters.getRangeFromSheetXC(sheetId, String(criterion.values[0]));
-          const criterionValues = this.getters.getRangeValues(range);
-          return criterionValues.map((value) => value?.toString()).filter(isDefined);
+          const values = [];
+          const labelsSet = new Set();
+          for (const p of positions(range.zone)) {
+              const cell = this.getters.getEvaluatedCell({ ...p, sheetId: range.sheetId });
+              if (cell.formattedValue && !labelsSet.has(cell.formattedValue)) {
+                  labelsSet.add(cell.formattedValue);
+                  values.push({ label: cell.formattedValue, value: cell.value?.toString() || "" });
+              }
+          }
+          return values;
       }
       isCellValidCheckbox(cellPosition) {
           if (!this.getters.isMainCellPosition(cellPosition)) {
@@ -75727,25 +75892,30 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const sheetId = this.composer.currentEditedCell.sheetId;
           const values = rule.criterion.type === "isValueInRange"
-              ? Array.from(new Set(this.getters.getDataValidationRangeValues(sheetId, rule.criterion)))
-              : rule.criterion.values;
+              ? this.getters.getDataValidationRangeValues(sheetId, rule.criterion)
+              : rule.criterion.values.map((value) => ({ label: value, value }));
           const isChip = rule.criterion.displayStyle === "chip";
           if (!isChip) {
-              return values.map((value) => ({ text: value }));
+              return values.map((value) => ({
+                  text: value.value,
+                  fuzzySearchKey: value.label,
+                  htmlContent: [{ value: value.label }],
+              }));
           }
           const colors = rule.criterion.colors;
           return values.map((value) => {
-              const color = colors?.[value];
+              const color = colors?.[value.value];
               return {
-                  text: value,
+                  text: value.value,
                   htmlContent: [
                       {
-                          value,
+                          value: value.label,
                           color: color ? chipTextColor(color) : undefined,
                           backgroundColor: color || GRAY_200,
                           classes: ["badge rounded-pill fs-6 fw-normal w-100 mt-1 text-start"],
                       },
                   ],
+                  fuzzySearchKey: value.label,
               };
           });
       },
@@ -79986,7 +80156,6 @@ stores.inject(MyMetaStore, storeInstance);
     }
   }
 
-  .o-spreadsheet-topbar-wrapper,
   .o-spreadsheet-bottombar-wrapper {
     z-index: ${ComponentsImportance.ScrollBar + 1};
   }
@@ -80101,7 +80270,6 @@ stores.inject(MyMetaStore, storeInstance);
               this.checkViewportSize();
               stores.on("store-updated", this, render);
               resizeObserver.observe(this.spreadsheetRef.el);
-              registerChartJSExtensions();
           });
           owl.onWillUnmount(() => {
               this.unbindModelEvents();
@@ -82747,7 +82915,7 @@ stores.inject(MyMetaStore, storeInstance);
         <dataBar>
           <cfvo type="min" val="0"/>
           <cfvo type="max" val="100"/>
-          <color rgb="${toXlsxHexColor(colorNumberString(rule.color))}"/>
+          <color rgb="${toXlsxHexColor(colorNumberToHex(rule.color))}"/>
         </dataBar>
       </cfRule>
     </conditionalFormatting>
@@ -82775,7 +82943,7 @@ stores.inject(MyMetaStore, storeInstance);
                   continue;
               }
               cfValueObject.push(thresholdAttributes(threshold, position));
-              colors.push([["rgb", toXlsxHexColor(colorNumberString(threshold.color))]]);
+              colors.push([["rgb", toXlsxHexColor(colorNumberToHex(threshold.color))]]);
           }
           if (!canExport) {
               console.warn("Conditional formats with formula rules are not supported at the moment. The rule is therefore skipped.");
@@ -84719,6 +84887,8 @@ stores.inject(MyMetaStore, storeInstance);
       WaterfallChartDesignPanel,
       ComboChartDesignPanel,
       FunnelChartDesignPanel,
+      SunburstChartDesignPanel,
+      TreeMapChartDesignPanel,
       ChartTypePicker,
       FigureComponent,
       MenuPopover,
@@ -84748,6 +84918,7 @@ stores.inject(MyMetaStore, storeInstance);
   };
   const stores = {
       useStoreProvider,
+      ChartDashboardMenuStore,
       DependencyContainer,
       CellPopoverStore,
       ComposerFocusStore,
@@ -84834,9 +85005,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.5.0-alpha.3";
-  __info__.date = "2025-07-28T13:43:05.981Z";
-  __info__.hash = "53dfee8";
+  __info__.version = "18.5.0-alpha.5";
+  __info__.date = "2025-08-04T06:53:29.412Z";
+  __info__.hash = "71c9a36";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);