@dynatrace/strato-components 3.2.1 → 3.3.0

package/filters/filter-field/utils/conversion/lezer-tree-conversion/parent-node/statement.js

@@ -24,9 +24,9 @@ module.exports = __toCommonJS(statement_exports);
 var import_inclusion = require("./inclusion.js");
 var import_is_node_environment = require("../../../../../../core/utils/is-node-environment.js");
 var import_decoration_marks = require("../../../../decorations/decoration-marks.js");
+var import_error_message_helpers = require("../../../error-utils/error-message-helpers.js");
 var import_get_text = require("../../../get-text.js");
 var import_suggestion_type = require("../../../suggestions-utils/suggestion-type.js");
-var import_type_guards = require("../../../validation-utils/type-guards.js");
 var import_validation_helper_functions = require("../../../validation-utils/validation-helper-functions.js");
 var import_exists = require("../comparator/exists.js");
 var import_operator = require("../comparator/operator.js");
@@ -36,7 +36,7 @@ var import_node_mutations = require("../node-mutations.js");
 var import_node_type_mapping = require("../node-type-mapping.js");
 var import_free_text = require("../value/free-text.js");
 var import_simple_value = require("../value/simple-value.js");
-function convertPositionOperators(convertedStatement, validatorMap, positionOperators, errors) {
+function convertPositionOperators(convertedStatement, internalValidatorMap, positionOperators, errors, parserConfig) {
   if (!convertedStatement.comparisonOperator || !positionOperators) {
     return;
   }
@@ -50,7 +50,8 @@ function convertPositionOperators(convertedStatement, validatorMap, positionOper
     if (!(0, import_validation_helper_functions.isValidOperator)(
       newValue,
       convertedStatement.key?.textValue,
-      validatorMap
+      internalValidatorMap,
+      parserConfig
     )) {
       (0, import_node_mutations.convertToErrorNode)(convertedStatement.value);
       for (const positionOperator of positionOperators.ranges) {
@@ -70,12 +71,12 @@ function convertPositionOperators(convertedStatement, validatorMap, positionOper
     }
   }
 }
-function validateKeyAndValue(validatorMap, convertedStatement, doc, errors, customTypes, parserConfig) {
-  if (!validatorMap?.keyPredicates || !convertedStatement.key) {
+function validateKeyAndValue(internalValidatorMap, convertedStatement, doc, errors, customTypes, parserConfig) {
+  if (!internalValidatorMap || internalValidatorMap.normalizedKeys.byKey.size === 0 || !convertedStatement.key) {
     return;
   }
   if (convertedStatement.key.type !== "Error") {
-    validateKey(convertedStatement.key, validatorMap, errors);
+    validateKey(convertedStatement.key, internalValidatorMap, errors);
   }
   if (!convertedStatement.value) {
     return;
@@ -85,8 +86,8 @@ function validateKeyAndValue(validatorMap, convertedStatement, doc, errors, cust
       validateSingleValue(
         value,
         doc,
-        convertedStatement,
-        validatorMap,
+        { ...convertedStatement, value },
+        internalValidatorMap,
         errors,
         customTypes,
         parserConfig
@@ -97,7 +98,7 @@ function validateKeyAndValue(validatorMap, convertedStatement, doc, errors, cust
       convertedStatement.value,
       doc,
       convertedStatement,
-      validatorMap,
+      internalValidatorMap,
       errors,
       customTypes,
       parserConfig
@@ -109,15 +110,15 @@ function validateKeyAndValue(validatorMap, convertedStatement, doc, errors, cust
     }
   }
 }
-function validateSingleValue(value, doc, convertedStatement, validatorMap, errors = [], customTypes, parserConfig) {
+function validateSingleValue(value, doc, convertedStatement, internalValidatorMap, errors = [], customTypes, parserConfig) {
   if (!value || !convertedStatement.key) {
     return true;
   }
-  const { isValid, message } = (0, import_validation_helper_functions.isValidValue)(
+  const { isValid, message, validTypes } = (0, import_validation_helper_functions.isValidValue)(
     convertedStatement.key.value,
     value.type === "String" ? value.value : value.textValue,
     value.type,
-    validatorMap,
+    internalValidatorMap,
     convertedStatement,
     doc.toString(),
     customTypes,
@@ -125,25 +126,46 @@ function validateSingleValue(value, doc, convertedStatement, validatorMap, error
   );
   if (!isValid) {
     (0, import_node_mutations.convertToErrorNode)(value);
-    errors.push({
-      range: value.range,
-      message: message ?? "invalidValueError"
-    });
+    if (!validTypes || validTypes.length === 1) {
+      const singleType = validTypes ? validTypes[0] : void 0;
+      if (singleType && (0, import_error_message_helpers.isCustomType)(singleType)) {
+        errors.push({
+          range: value.range,
+          message: message ?? {
+            type: "invalidValueErrorMultipleTypes",
+            details: validTypes
+          }
+        });
+      } else {
+        errors.push({
+          range: value.range,
+          message: message ?? (0, import_error_message_helpers.getErrorMessageForType)(singleType)
+        });
+      }
+    } else {
+      errors.push({
+        range: value.range,
+        message: message ?? {
+          type: "invalidValueErrorMultipleTypes",
+          details: validTypes
+        }
+      });
+    }
   }
   return isValid;
 }
-function validateKey(key, validatorMap, errors = []) {
-  if (!validatorMap || !key || !validatorMap.keyPredicates) {
-    return true;
+function validateKey(key, internalValidatorMap, errors = []) {
+  if (!internalValidatorMap || !key) {
+    return;
   }
-  const isExhaustive = validatorMap.exhaustive ?? true;
+  const isExhaustive = internalValidatorMap.exhaustive ?? true;
   let { value } = key;
   let isValidJsonPath = true;
   if (key.type === "JSONPath") {
     value = key.root;
-    isValidJsonPath = hasJSONPathTypePredicate(validatorMap, value);
+    isValidJsonPath = hasJSONPathTypePredicate(internalValidatorMap, value);
   }
-  const keyIsInValidatorMap = Array.isArray(validatorMap.keyPredicates) && validatorMap.keyPredicates.includes(value) || value in validatorMap.keyPredicates;
+  const keyIsInValidatorMap = internalValidatorMap.normalizedKeys.byKey.has(value);
   if ((!keyIsInValidatorMap || !isValidJsonPath) && isExhaustive) {
     (0, import_node_mutations.convertToErrorNode)(key);
     errors.push({
@@ -152,7 +174,7 @@ function validateKey(key, validatorMap, errors = []) {
     });
   }
 }
-function convertFilterStatement(node, doc, numberParser, validatorMap, customTypes, parserConfig, context) {
+function convertFilterStatement(node, doc, numberParser, internalValidatorMap, customTypes, parserConfig, context) {
   const nodeName = node.name;
   const { from, to } = node;
   const cursor = node.node.cursor();
@@ -227,7 +249,13 @@ function convertFilterStatement(node, doc, numberParser, validatorMap, customTyp
         return updatePreviousAndContinue(nodeName2);
       }
       case "FilterIncludesValue": {
-        const { convertedNode: value, errors: valueErrors } = (0, import_inclusion.convertInclusionValue)(childNode, doc, numberParser, customTypes, parserConfig);
+        const { convertedNode: value, errors: valueErrors } = (0, import_inclusion.convertInclusionValue)(
+          childNode,
+          doc,
+          numberParser,
+          customTypes,
+          parserConfig
+        );
         convertedStatement.value = value;
         errors.push(...valueErrors);
         return updatePreviousAndContinue(nodeName2);
@@ -291,7 +319,7 @@ function convertFilterStatement(node, doc, numberParser, validatorMap, customTyp
                   };
                   errors.push({
                     range,
-                    message: "invalidValueError"
+                    message: "invalidValueErrorGeneric"
                   });
                 }
               } else {
@@ -330,13 +358,14 @@ function convertFilterStatement(node, doc, numberParser, validatorMap, customTyp
   if (convertedStatement.comparisonOperator && positionOperators) {
     convertPositionOperators(
       convertedStatement,
-      validatorMap,
+      internalValidatorMap,
       positionOperators,
-      errors
+      errors,
+      parserConfig
     );
   }
   validateKeyAndValue(
-    validatorMap,
+    internalValidatorMap,
     convertedStatement,
     doc,
     errors,
@@ -347,7 +376,7 @@ function convertFilterStatement(node, doc, numberParser, validatorMap, customTyp
   if (operator && !positionOperators && (!(0, import_validation_helper_functions.isValidOperator)(
     operator.textValue,
     convertedStatement.key?.value,
-    validatorMap,
+    internalValidatorMap,
     parserConfig
   ) || operator.type === "Error" && operator.value !== "*~")) {
     (0, import_node_mutations.convertToErrorNode)(operator);
@@ -360,7 +389,7 @@ function convertFilterStatement(node, doc, numberParser, validatorMap, customTyp
         type: "invalidComparatorError",
         details: (0, import_validation_helper_functions.getValidOperatorsColored)(
           convertedStatement.key?.textValue,
-          validatorMap,
+          internalValidatorMap,
           parserConfig
         )
       }
@@ -368,12 +397,16 @@ function convertFilterStatement(node, doc, numberParser, validatorMap, customTyp
   }
   return { convertedNode: convertedStatement, errors };
 }
-function hasJSONPathTypePredicate(validatorMap, key) {
-  if (validatorMap.keyPredicates === void 0 || !validatorMap.keyPredicates || Array.isArray(validatorMap.keyPredicates)) {
+function hasJSONPathTypePredicate(internalValidatorMap, key) {
+  const config = internalValidatorMap.normalizedKeys.byKey.get(key);
+  if (!config) {
     return false;
   }
-  const predicate = validatorMap.keyPredicates[key];
-  const validValues = (0, import_type_guards.isFilterFieldValidatorMapTypeSpecification)(predicate) ? predicate : predicate?.valuePredicate;
+  if (config.valueType) {
+    const types = Array.isArray(config.valueType) ? config.valueType : [config.valueType];
+    return types.includes("JSONPath");
+  }
+  const validValues = config.valuePredicate;
   if (!validValues || typeof validValues === "function") {
     return false;
   }

package/filters/filter-field/utils/conversion/lezer-tree-conversion/value/simple-value.js

@@ -194,7 +194,7 @@ function convertSimpleValue(node, doc, numberParser, customTypes, parserConfig)
     );
     errors.push({
       range: { from, to },
-      message: "invalidValueError"
+      message: "invalidValueErrorGeneric"
     });
   }
   let combinedPositionOperators = positionOperators ?? positionOperatorsInsideString;

package/filters/filter-field/utils/conversion/string-tree-conversion.js

@@ -24,6 +24,7 @@ module.exports = __toCommonJS(string_tree_conversion_exports);
 var import_tree_conversion = require("./tree-conversion.js");
 var import_getNumberParser = require("../../parser/getNumberParser.js");
 var import_parser = require("../../parser/parser.js");
+var import_normalize_validator_map = require("../../utils/validation-utils/normalize-validator-map.js");
 function convertStringToFilterFieldTree(filterString, optionsOrValidatorMap, parserConfig) {
   let validatorMap;
   let customTypes = void 0;
@@ -42,7 +43,7 @@ function convertStringToFilterFieldTree(filterString, optionsOrValidatorMap, par
     tree: parsedTree,
     numberParser,
     doc: filterString,
-    validatorMap,
+    internalValidatorMap: (0, import_normalize_validator_map.toInternalValidatorMap)(validatorMap),
     customTypes,
     parserConfig: _parserConfig
   });

package/filters/filter-field/utils/conversion/tree-conversion.d.ts

@@ -3,7 +3,8 @@ import type { Tree } from '@lezer/common';
 import type { FilterFieldProps } from '../../FilterField.types.js';
 import type { NumberFormatParser } from '../../parser/getNumberParser.js';
 import type { FilterFieldTree } from '../../types/tree-nodes.js';
-import type { FilterFieldCustomTypes, FilterFieldValidatorMap } from '../../types/validation.js';
+import type { FilterFieldCustomTypes } from '../../types/validation.js';
+import type { InternalValidatorMap } from '../../utils/validation-utils/normalize-validator-map.js';
 /**
  * Used parser version
  * @internal
@@ -13,12 +14,12 @@ export declare const parserVersion = "004";
  * Iterate over the parsed document and convert the lezer tree to an object.
  * @internal
  */
-export declare function convertLezerTree({ tree, view, numberParser, doc, validatorMap, customTypes, parserConfig, }: {
+export declare function convertLezerTree({ tree, view, numberParser, doc, internalValidatorMap, customTypes, parserConfig, }: {
     tree: Tree;
     numberParser: NumberFormatParser;
     view?: EditorView;
     doc?: string;
-    validatorMap?: FilterFieldValidatorMap;
+    internalValidatorMap?: InternalValidatorMap;
     customTypes?: FilterFieldCustomTypes;
     parserConfig?: FilterFieldProps['parserConfig'];
 }): {

package/filters/filter-field/utils/conversion/tree-conversion.js

@@ -22,16 +22,16 @@ __export(tree_conversion_exports, {
   parserVersion: () => parserVersion
 });
 module.exports = __toCommonJS(tree_conversion_exports);
+var import_tree_precedence = require("./tree-precedence.js");
 var import_editor_config = require("../../editor-state-configs/editor-config.js");
 var import_group = require("./lezer-tree-conversion/parent-node/group.js");
-var import_tree_precedence = require("./tree-precedence.js");
 const parserVersion = "004";
 function convertLezerTree({
   tree,
   view,
   numberParser,
   doc,
-  validatorMap,
+  internalValidatorMap,
   customTypes,
   parserConfig
 }) {
@@ -44,7 +44,7 @@ function convertLezerTree({
     tree,
     numberParser,
     doc,
-    validatorMap,
+    internalValidatorMap,
     customTypes,
     parserConfig
   });
@@ -71,7 +71,7 @@ function convertFlatLezerTree({
   tree,
   numberParser,
   doc,
-  validatorMap,
+  internalValidatorMap,
   customTypes,
   parserConfig
 }) {
@@ -97,7 +97,7 @@ function convertFlatLezerTree({
           node,
           doc,
           numberParser,
-          validatorMap,
+          internalValidatorMap,
           customTypes,
           parserConfig,
           "Filter"

package/filters/filter-field/utils/error-utils/error-message-helpers.d.ts

@@ -0,0 +1,10 @@
+import type { filterFieldMessages } from '../../messages.js';
+import type { FilterFieldCustomTypes, FilterFieldValuePredicate } from '../../types/validation.js';
+/** @internal */
+export declare function getTypeLabelKey(type: string): keyof typeof filterFieldMessages.linting.typeLabels | undefined;
+/** @internal */
+export declare function getCustomTypeLabel(type: string, customTypes?: FilterFieldCustomTypes): string | undefined;
+/** @internal */
+export declare function isCustomType(type: string): boolean;
+/** @internal */
+export declare function getErrorMessageForType(type: FilterFieldValuePredicate | undefined): string;

package/filters/filter-field/utils/error-utils/error-message-helpers.js

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_message_helpers_exports = {};
+__export(error_message_helpers_exports, {
+  getCustomTypeLabel: () => getCustomTypeLabel,
+  getErrorMessageForType: () => getErrorMessageForType,
+  getTypeLabelKey: () => getTypeLabelKey,
+  isCustomType: () => isCustomType
+});
+module.exports = __toCommonJS(error_message_helpers_exports);
+const builtInTypeLabelKeys = {
+  Duration: "Durations",
+  Number: "Numbers",
+  String: "Strings",
+  IPAddress: "IPAddresses",
+  UID: "UIDs",
+  Timestamp: "Timestamps",
+  SmartscapeId: "SmartscapeIds",
+  Boolean: "Boolean"
+};
+function getTypeLabelKey(type) {
+  return builtInTypeLabelKeys[type];
+}
+function getCustomTypeLabel(type, customTypes) {
+  if (!customTypes) {
+    return void 0;
+  }
+  const customType = customTypes[type];
+  if (customType && typeof customType === "object" && customType.label) {
+    return customType.label;
+  }
+  return void 0;
+}
+function isCustomType(type) {
+  return !builtInTypeLabelKeys[type] && type !== "Any" && type !== "JSONPath";
+}
+function getErrorMessageForType(type) {
+  switch (type) {
+    case "Boolean":
+      return "invalidValueErrorBoolean";
+    case "Duration":
+      return "invalidValueErrorDurations";
+    case "Number":
+      return "invalidValueErrorNumbers";
+    case "IPAddress":
+      return "invalidValueErrorIPAddresses";
+    case "UID":
+      return "invalidValueErrorUIDs";
+    case "SmartscapeId":
+      return "invalidValueErrorSmartscapeIds";
+    case "Timestamp":
+      return "invalidValueErrorTimestamps";
+    case "String":
+      return "invalidValueErrorStrings";
+    case "Any":
+    default:
+      return "invalidValueErrorGeneric";
+  }
+}

package/filters/filter-field/utils/generate-errors-or-diagnostics.js

@@ -74,7 +74,13 @@ function generateErrorsOrDiagnostics(view, messages) {
         let errorMessage2 = message;
         const errorType = messages[message];
         if (errorType) {
-          errorMessage2 = typeof errorType === "function" ? errorType(messageDetails) : errorType;
+          if (typeof errorType === "function") {
+            errorMessage2 = errorType(
+              messageDetails
+            );
+          } else {
+            errorMessage2 = errorType;
+          }
         }
         if (showError) {
           diagnostics.push({

package/filters/filter-field/utils/migrate-validator-map.d.ts

@@ -0,0 +1,50 @@
+import type { FilterFieldValidatorMap } from '../types/validation.js';
+/**
+ * NOTE:
+ * This util is supposed to be used as a one-off migration helper. If you are dynamically generating `FilterFieldValidatorMap`
+ * objects, you should update your code to produce the new format directly instead of using this function.
+ *
+ * Converts a `FilterFieldValidatorMap` from the deprecated object notation of `keyPredicates`
+ * to the new array notation.
+ *
+ * The following transformations are applied:
+ * - Each object key is moved into the `key` field of a `FilterFieldKeySuggestionConfig`.
+ * - A bare type predicate (`{ type: 'String' }`) used as valuePredicate for a key is
+ *   moved to the `valueType` prop.
+ * - A `FilterFieldValidatorMapTypePredicate` used inside a `valuePredicate` array
+ *   is extracted to `valueType`. If it was the only item in a `valuePredicate` array, that
+ *   array is dropped entirely.
+ * - Multiple type predicates in a `valuePredicate` array are merged and deduplicated into
+ *   a single `valueType`.
+ * - Deprecated `FilterFieldDuration` objects in `valuePredicate` (and inside
+ *   `FilterFieldValueSuggestionGroupConfig.suggestions`) are converted to their string
+ *   equivalents (e.g. `{ value: 10, unit: 'ms' }` → `'10ms'`).
+ * - All other configuration props (`comparisonOperators`, `fallbackKey`,
+ *   `suggestStatementOnValueMatch`, `displayValue`, `details`) are preserved as-is.
+ *
+ * If `keyPredicates` is already in array notation or is `undefined`, the original map
+ * object is returned unchanged.
+ *
+ * @example
+ * ```ts
+ * const validatorMap = migrateFilterFieldKeyPredicatesToArray({
+ *   keyPredicates: {
+ *     myKey1: { type: 'String' },
+ *     myKey2: { valuePredicate: { type: ['String', 'Number'] }, comparisonOperators: ['equals'] },
+ *     myKey3: { valuePredicate: [{ type: 'String' }, 'literal1', 'literal2'] },
+ *     myKey4: { valuePredicate: [{ value: 10, unit: 'ms' }, { value: 1, unit: 's' }] },
+ *   },
+ * });
+ * // Result:
+ * // {
+ * //   keyPredicates: [
+ * //     { key: 'myKey1', valueType: 'String' },
+ * //     { key: 'myKey2', valueType: ['String', 'Number'], comparisonOperators: ['equals'] },
+ * //     { key: 'myKey3', valueType: 'String', valuePredicate: ['literal1', 'literal2'] },
+ * //     { key: 'myKey4', valuePredicate: ['10ms', '1s'] },
+ * //   ],
+ * // }
+ * ```
+ * @public
+ */
+export declare function migrateFilterFieldKeyPredicatesToArray(validatorMap: FilterFieldValidatorMap): FilterFieldValidatorMap;

package/filters/filter-field/utils/migrate-validator-map.js

@@ -0,0 +1,115 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var migrate_validator_map_exports = {};
+__export(migrate_validator_map_exports, {
+  migrateFilterFieldKeyPredicatesToArray: () => migrateFilterFieldKeyPredicatesToArray
+});
+module.exports = __toCommonJS(migrate_validator_map_exports);
+var import_type_guards = require("./validation-utils/type-guards.js");
+function migrateValuePredicate(valuePredicate) {
+  if (typeof valuePredicate === "function") {
+    return { valuePredicate };
+  }
+  if ((0, import_type_guards.isFilterFieldValidatorMapTypeSpecification)(valuePredicate)) {
+    const raw = valuePredicate.type;
+    const types = Array.isArray(raw) ? raw : [raw];
+    const valueType = normalizeCollectedTypes([...new Set(types)]);
+    return { valueType };
+  }
+  if ((0, import_type_guards.isFilterFieldValidatorMapDurationSpecification)(valuePredicate)) {
+    return { valuePredicate: `${valuePredicate.value}${valuePredicate.unit}` };
+  }
+  if ((0, import_type_guards.isFilterFieldValueSuggestionGroupConfig)(valuePredicate)) {
+    return {
+      valuePredicate: {
+        ...valuePredicate,
+        suggestions: valuePredicate.suggestions.map(migrateValuePredicateItem)
+      }
+    };
+  }
+  if (Array.isArray(valuePredicate)) {
+    return migrateValuePredicateArray(valuePredicate);
+  }
+  return { valuePredicate };
+}
+function migrateFilterFieldKeyPredicatesToArray(validatorMap) {
+  const { keyPredicates } = validatorMap;
+  if (keyPredicates === void 0 || Array.isArray(keyPredicates)) {
+    return validatorMap;
+  }
+  const result = Object.entries(
+    keyPredicates
+  ).map(([key, config]) => {
+    if ((0, import_type_guards.isFilterFieldValidatorMapTypeSpecification)(config)) {
+      const raw = config.type;
+      const types = Array.isArray(raw) ? raw : [raw];
+      return { key, valueType: normalizeCollectedTypes([...new Set(types)]) };
+    }
+    const { valuePredicate, ...rest } = config;
+    if (valuePredicate === void 0) {
+      return { key, ...rest };
+    }
+    const { valueType, valuePredicate: migratedPredicate } = migrateValuePredicate(valuePredicate);
+    return {
+      key,
+      ...rest,
+      ...valueType !== void 0 && { valueType },
+      ...migratedPredicate !== void 0 && {
+        valuePredicate: migratedPredicate
+      }
+    };
+  });
+  return { ...validatorMap, keyPredicates: result };
+}
+function migrateValuePredicateItem(item) {
+  if ((0, import_type_guards.isFilterFieldValidatorMapDurationSpecification)(item)) {
+    return `${item.value}${item.unit}`;
+  }
+  return item;
+}
+function normalizeCollectedTypes(types) {
+  if (types.length === 0) {
+    return void 0;
+  }
+  return types.length === 1 ? types[0] : types;
+}
+function migrateValuePredicateArray(items) {
+  const collectedTypes = [];
+  const remaining = [];
+  for (const item of items) {
+    if ((0, import_type_guards.isFilterFieldValidatorMapTypeSpecification)(item)) {
+      const types = Array.isArray(item.type) ? item.type : [item.type];
+      for (const t of types) {
+        if (!collectedTypes.includes(t)) {
+          collectedTypes.push(t);
+        }
+      }
+    } else if ((0, import_type_guards.isFilterFieldValueSuggestionGroupConfig)(item)) {
+      remaining.push({
+        ...item,
+        suggestions: item.suggestions.map(migrateValuePredicateItem)
+      });
+    } else {
+      remaining.push(migrateValuePredicateItem(item));
+    }
+  }
+  const valueType = normalizeCollectedTypes(collectedTypes);
+  const valuePredicate = remaining.length === 0 ? void 0 : remaining.length === 1 ? remaining[0] : remaining;
+  return { valueType, valuePredicate };
+}

package/filters/filter-field/utils/suggestions-utils/flatten-suggestions.js

@@ -34,7 +34,13 @@ function flattenSuggestions(items) {
     const item = items[index];
     if ((0, import_react.isValidElement)(item)) {
       if ((0, import_is_slot.isSlot)(item, import_SuggestionGroup.SuggestionGroup)) {
-        const { label, suggestions, children, id } = item.props;
+        const {
+          label,
+          suggestions,
+          children,
+          id,
+          "aria-label": ariaLabel
+        } = item.props;
         const groupId = id ?? `__group_${index}`;
         const childArray = import_react.Children.toArray(children);
         const labelSlot = (0, import_is_slot.isSlot)(childArray[0], import_SuggestionGroupLabel.SuggestionGroupLabel) ? childArray[0] : void 0;
@@ -44,7 +50,8 @@ function flattenSuggestions(items) {
           continue;
         }
         const hasLabel = labelSlot !== void 0 || label !== void 0;
-        const shouldAddHeader = hasLabel || !isFirstGroup;
+        const hasAriaLabel = ariaLabel !== void 0;
+        const shouldAddHeader = hasLabel || hasAriaLabel || !isFirstGroup;
         isFirstGroup = false;
         if (shouldAddHeader) {
           if (labelSlot) {
@@ -63,6 +70,9 @@ function flattenSuggestions(items) {
             groupMetadata.push({ groupId, label });
           } else {
             flattenedSuggestionItems.push({ kind: "group-header", groupId });
+            if (hasAriaLabel) {
+              groupMetadata.push({ groupId, label: ariaLabel });
+            }
           }
         }
         if (suggestions) {
@@ -92,7 +102,8 @@ function flattenSuggestions(items) {
         continue;
       }
       const hasLabel = item.label !== void 0;
-      const shouldAddHeader = hasLabel || !isFirstGroup;
+      const hasAriaLabel = item["aria-label"] !== void 0;
+      const shouldAddHeader = hasLabel || hasAriaLabel || !isFirstGroup;
       isFirstGroup = false;
       if (shouldAddHeader) {
         flattenedSuggestionItems.push({
@@ -100,8 +111,11 @@ function flattenSuggestions(items) {
           label: item.label,
           groupId
         });
-        if (hasLabel) {
-          groupMetadata.push({ groupId, label: item.label });
+        if (hasLabel || hasAriaLabel) {
+          groupMetadata.push({
+            groupId,
+            label: item.label ?? item["aria-label"]
+          });
         }
       }
       for (const s of item.suggestions) {