@dynatrace/strato-components 3.13.2 → 3.14.0

package/filters/filter-field/utils/value-operations/remove-filter.d.ts

@@ -1,4 +1,5 @@
-import type { FilterFieldValueOperationResult, FilterFieldValueOperationStatement } from '../../types/value-operations.js';
+import type { FilterFieldProps } from '../../FilterField.types.js';
+import type { FilterFieldRemoveStatement, FilterFieldValueOperationResult } from '../../types/value-operations.js';
 /**
  * Removes a filter statement or value from an existing FilterField value string.
  *
@@ -6,14 +7,24 @@ import type { FilterFieldValueOperationResult, FilterFieldValueOperationStatemen
  * - If removing a value from `key in (v1, v2)` leaves one value, the statement collapses to `key = v1`.
  * - When multiple statements with the same key, operator and value exist, the rightmost one (in document order) is removed.
  * - When `options.removeAll` is `true`, all matching occurrences are removed instead of only the rightmost one.
+ * - Passing a key-only statement (`{ key }`, without `value` or `comparisonOperator`) matches every
+ *   statement for that key regardless of operator or value — combine with `removeAll` to clear the key.
  *
  * @public
  * @param currentValue - The current FilterField value string.
- * @param filter - The filter statement or value to remove.
- * @param options - Optional configuration for the remove operation.
+ * @param filter - The filter statement or value to remove. Pass `valueType` on the filter to match
+ *                 against values added with the same type hint — e.g. `valueType: 'String'` removes
+ *                 only a `String` leaf, not a Boolean leaf of the same value. For the flag-gated
+ *                 types (`'IPAddress'`, `'Timestamp'`, `'UID'`, `'SmartscapeId'`) pass the matching
+ *                 `options.parserConfig` flag as well, otherwise the value resolves to a `String`.
+ * @param options - Optional configuration for the remove operation. `parserConfig` controls how
+ *                  `currentValue` is parsed and how `valueType` is resolved; pass the same config
+ *                  used for the corresponding `addFilter` call so removal stays symmetric.
  * @returns The new FilterField value string and whether the operation produced a change.
  */
-export declare function removeFilter(currentValue: string, filter: FilterFieldValueOperationStatement, options?: {
+export declare function removeFilter(currentValue: string, filter: FilterFieldRemoveStatement, options?: {
     removeAll?: boolean;
+    /** Parser config to apply when interpreting the existing value and resolving `valueType`. */
+    parserConfig?: FilterFieldProps['parserConfig'];
 }): FilterFieldValueOperationResult;
 //# sourceMappingURL=remove-filter.d.ts.map

package/filters/filter-field/utils/value-operations/remove-filter.js

@@ -26,20 +26,41 @@ var import_tree_string_conversion = require("../conversion/tree-string-conversio
 var import_tree_node_guards = require("../tree-node-guards.js");
 var import_operator_specification = require("../validation-utils/operator-specification.js");
 function removeFilter(currentValue, filter, options) {
+  const parserConfig = {
+    ...options?.parserConfig,
+    // Search and mid-value wildcard statements must always be recognized so they
+    // can be targeted for removal regardless of the caller's config.
+    searchConversion: true,
+    matchesWildcardConversion: true
+  };
   const { tree } = (0, import_string_tree_conversion.convertStringToFilterFieldTree)(currentValue, {
     validatorMap: {
       comparisonOperators: [...import_operator_specification.FILTERFIELD_ALL_OPERATORS]
     },
-    parserConfig: {
-      searchConversion: true,
-      matchesWildcardConversion: true
-    }
+    parserConfig
   });
   if (!tree) {
     return { updatedStatement: false, value: currentValue };
   }
-  const operator = (0, import_value_operation_utils.mapInputOperator)(filter.comparisonOperator);
   let updatedStatement = false;
+  if (filter.key !== void 0 && !("value" in filter) && !("comparisonOperator" in filter)) {
+    do {
+      const found = removeRightmostMatch(tree, (statement) => {
+        const statementKey = statement.key;
+        return !!statementKey && (statementKey.type === "Key" || statementKey.type === "JSONPath") && statementKey.value === filter.key;
+      });
+      if (!found) {
+        break;
+      }
+      updatedStatement = true;
+    } while (options?.removeAll);
+    return updatedStatement ? { updatedStatement: true, value: (0, import_tree_string_conversion.convertFilterFieldTreeToString)(tree) } : { updatedStatement: false, value: currentValue };
+  }
+  const operator = (0, import_value_operation_utils.mapInputOperator)(filter.comparisonOperator);
+  const leafOptions = {
+    valueType: filter.valueType,
+    parserConfig
+  };
   if (operator.node.type === "SearchOperator") {
     if (filter.value === void 0) {
       return { updatedStatement: false, value: currentValue };
@@ -50,7 +71,8 @@ function removeFilter(currentValue, filter, options) {
         const statementValue = statement.value;
         return statementOperator?.type === "SearchOperator" && statementValue !== void 0 && !(0, import_tree_node_guards.isFilterFieldListNode)(statementValue) && (0, import_value_operation_utils.leafEquals)(
           statementValue,
-          filter.value
+          filter.value,
+          leafOptions
         );
       });
       if (!found) {
@@ -78,7 +100,11 @@ function removeFilter(currentValue, filter, options) {
           return true;
         }
         const statementValue = statement.value;
-        return statementValue !== void 0 && !(0, import_tree_node_guards.isFilterFieldListNode)(statementValue) && statementValue.type !== "Error" && (0, import_value_operation_utils.leafEquals)(statementValue, filter.value);
+        return statementValue !== void 0 && !(0, import_tree_node_guards.isFilterFieldListNode)(statementValue) && statementValue.type !== "Error" && (0, import_value_operation_utils.leafEquals)(
+          statementValue,
+          filter.value,
+          leafOptions
+        );
       });
       if (!found) {
         break;
@@ -92,7 +118,8 @@ function removeFilter(currentValue, filter, options) {
       tree,
       filter.key,
       operator.polarity,
-      filter.value
+      filter.value,
+      leafOptions
     );
     if (!found) {
       break;
@@ -124,11 +151,17 @@ function removeRightmostMatch(group, predicate) {
   }
   return false;
 }
-function removeOrMutateRightmostPolarityMatch(group, key, polarity, value) {
+function removeOrMutateRightmostPolarityMatch(group, key, polarity, value, leafOptions) {
   for (let i = group.children.length - 1; i >= 0; i--) {
     const child = group.children[i];
     if ((0, import_tree_node_guards.isFilterFieldGroupNode)(child)) {
-      if (removeOrMutateRightmostPolarityMatch(child, key, polarity, value)) {
+      if (removeOrMutateRightmostPolarityMatch(
+        child,
+        key,
+        polarity,
+        value,
+        leafOptions
+      )) {
         if (child.children.length === 0) {
           group.children.splice(i, 1);
         }
@@ -149,7 +182,7 @@ function removeOrMutateRightmostPolarityMatch(group, key, polarity, value) {
       if ((0, import_tree_node_guards.isFilterFieldListNode)(statementValue)) {
         const list = statementValue;
         const valueIndex = list.value.findIndex(
-          (leaf) => (0, import_value_operation_utils.leafEquals)(leaf, value)
+          (leaf) => (0, import_value_operation_utils.leafEquals)(leaf, value, leafOptions)
         );
         if (valueIndex === -1) {
           continue;
@@ -171,7 +204,11 @@ function removeOrMutateRightmostPolarityMatch(group, key, polarity, value) {
           list.value.splice(valueIndex, 1);
         }
         return true;
-      } else if (statementValue.type !== "Error" && (0, import_value_operation_utils.leafEquals)(statementValue, value)) {
+      } else if (statementValue.type !== "Error" && (0, import_value_operation_utils.leafEquals)(
+        statementValue,
+        value,
+        leafOptions
+      )) {
         group.children.splice(i, 1);
         if (group.children.length === 1) {
           recursiveClearExplicitGroup(group);

package/filters/filter-field/utils/value-operations/value-operation-utils.d.ts

@@ -1,4 +1,6 @@
-import type { SimpleFilterFieldComparisonOperatorNode, SimpleFilterFieldExistsOperatorNode, SimpleFilterFieldGroupNode, SimpleFilterFieldInclusionOperatorNode, SimpleFilterFieldLeafNode, SimpleFilterFieldSearchOperatorNode, SimpleFilterFieldStatementNode } from '../../types/conversion-tree-nodes.js';
+import type { FilterFieldProps } from '../../FilterField.types.js';
+import type { SimpleFilterFieldBooleanNode, SimpleFilterFieldComparisonOperatorNode, SimpleFilterFieldDurationNode, SimpleFilterFieldExistsOperatorNode, SimpleFilterFieldGroupNode, SimpleFilterFieldIPAddressNode, SimpleFilterFieldInclusionOperatorNode, SimpleFilterFieldLeafNode, SimpleFilterFieldNumberNode, SimpleFilterFieldSearchOperatorNode, SimpleFilterFieldSmartscapeIdNode, SimpleFilterFieldStatementNode, SimpleFilterFieldStringNode, SimpleFilterFieldTimestampNode, SimpleFilterFieldUIDNode, SimpleFilterFieldVariableNode } from '../../types/conversion-tree-nodes.js';
+import type { FilterFieldPrimitive } from '../../types/validation.js';
 /** @internal */
 export declare const DURATION_REGEX: RegExp;
 /** @internal */
@@ -18,10 +20,37 @@ export declare const OPERATOR_MAP: Partial<Record<string, OperatorDescriptor>>;
 export declare function mapInputOperator(operator: string | undefined): OperatorDescriptor;
 /** @internal */
 export declare function statementPolarity(statement: SimpleFilterFieldStatementNode): Polarity;
-/** @internal */
-export declare function leafEquals(leaf: SimpleFilterFieldLeafNode, value: string | number | boolean): boolean;
-/** @internal */
-export declare function findSearchStatement(group: SimpleFilterFieldGroupNode, value: string | number | boolean): SimpleFilterFieldStatementNode | undefined;
-/** @internal */
-export declare function findIdenticalStatement(group: SimpleFilterFieldGroupNode, key: string, operatorNode: NewOperatorNode, value: string | number | boolean | undefined): SimpleFilterFieldStatementNode | undefined;
+/**
+ * Accepted shape for the value-type hint on `addFilter` / `removeFilter`.
+ *
+ * `'Any'`, `'JSONPath'`, and unrecognized custom type names fall back to the
+ * default inference behavior.
+ * @internal
+ */
+export type FilterFieldValueTypeHint = FilterFieldPrimitive | (string & {});
+type LeafNode = SimpleFilterFieldStringNode | SimpleFilterFieldNumberNode | SimpleFilterFieldBooleanNode | SimpleFilterFieldDurationNode | SimpleFilterFieldVariableNode | SimpleFilterFieldIPAddressNode | SimpleFilterFieldTimestampNode | SimpleFilterFieldUIDNode | SimpleFilterFieldSmartscapeIdNode;
+/**
+ * Builds the appropriate leaf node for the given `value`, optionally constrained
+ * by a `valueType` hint. When no hint is given (or the hint is `'Any'` /
+ * `'JSONPath'` / an unrecognized custom name), the type is inferred from the
+ * value's content — matching the historical behavior.
+ * @internal
+ */
+export declare function makeLeaf(value: string | number | boolean, parserConfig: FilterFieldProps['parserConfig'], valueType?: FilterFieldValueTypeHint): LeafNode;
+/** @internal */
+export declare function leafEquals(leaf: SimpleFilterFieldLeafNode, value: string | number | boolean, options?: {
+    valueType?: FilterFieldValueTypeHint;
+    parserConfig?: FilterFieldProps['parserConfig'];
+}): boolean;
+/** @internal */
+export declare function findSearchStatement(group: SimpleFilterFieldGroupNode, value: string | number | boolean, options?: {
+    valueType?: FilterFieldValueTypeHint;
+    parserConfig?: FilterFieldProps['parserConfig'];
+}): SimpleFilterFieldStatementNode | undefined;
+/** @internal */
+export declare function findIdenticalStatement(group: SimpleFilterFieldGroupNode, key: string, operatorNode: NewOperatorNode, value: string | number | boolean | undefined, options?: {
+    valueType?: FilterFieldValueTypeHint;
+    parserConfig?: FilterFieldProps['parserConfig'];
+}): SimpleFilterFieldStatementNode | undefined;
+export {};
 //# sourceMappingURL=value-operation-utils.d.ts.map

package/filters/filter-field/utils/value-operations/value-operation-utils.js

@@ -23,12 +23,14 @@ __export(value_operation_utils_exports, {
   findIdenticalStatement: () => findIdenticalStatement,
   findSearchStatement: () => findSearchStatement,
   leafEquals: () => leafEquals,
+  makeLeaf: () => makeLeaf,
   mapInputOperator: () => mapInputOperator,
   statementPolarity: () => statementPolarity
 });
 module.exports = __toCommonJS(value_operation_utils_exports);
 var import_getNumberParser = require("../../parser/getNumberParser.js");
 var import_tree_node_guards = require("../tree-node-guards.js");
+var import_type_validators = require("../validation-utils/type-validators.js");
 const DURATION_REGEX = /^(\d+)(ns|ms|s|m|h|d)$/i;
 const VARIABLE_REGEX = /^\$[A-Za-z_]\w*$/;
 const OPERATOR_MAP = {
@@ -107,7 +109,150 @@ function statementPolarity(statement) {
   }
   return "none";
 }
-function leafEquals(leaf, value) {
+function isExplicitValueType(hint) {
+  return hint !== void 0 && hint !== "Any" && hint !== "JSONPath" && // Built-in primitives: String, Number, Boolean, Duration, IPAddress, UID, Timestamp, SmartscapeId
+  (hint === "String" || hint === "Number" || hint === "Boolean" || hint === "Duration" || hint === "IPAddress" || hint === "Timestamp" || hint === "UID" || hint === "SmartscapeId");
+}
+function makeTypedLeaf(value, parserConfig, valueType) {
+  if (!isExplicitValueType(valueType)) {
+    return void 0;
+  }
+  switch (valueType) {
+    case "String":
+      return { type: "String", value: String(value) };
+    case "Boolean": {
+      if (typeof value === "boolean") {
+        return { type: "Boolean", value };
+      }
+      if (value === "true" || value === "false") {
+        return { type: "Boolean", value: value === "true" };
+      }
+      return void 0;
+    }
+    case "Number": {
+      if (typeof value === "number") {
+        return { type: "Number", value };
+      }
+      if (typeof value === "string") {
+        const parsed = (0, import_getNumberParser.getNumberParser)().parse(value);
+        if (!isNaN(parsed)) {
+          return { type: "Number", value: parsed };
+        }
+      }
+      return void 0;
+    }
+    case "Duration": {
+      const match = DURATION_REGEX.exec(String(value));
+      if (match) {
+        return {
+          type: "Duration",
+          value: parseInt(match[1], 10),
+          unit: match[2].toLowerCase()
+        };
+      }
+      return void 0;
+    }
+    case "IPAddress": {
+      const str = String(value);
+      if (parserConfig?.ipAddressConversion && (0, import_type_validators.isValidIPAddress)(str)) {
+        return { type: "IPAddress", value: str, textValue: str };
+      }
+      return void 0;
+    }
+    case "Timestamp": {
+      const str = String(value);
+      if (parserConfig?.timestampConversion && (0, import_type_validators.isValidTimestamp)(str)) {
+        return { type: "Timestamp", value: str, textValue: str };
+      }
+      return void 0;
+    }
+    case "UID": {
+      const str = String(value);
+      if (parserConfig?.uidConversion && (0, import_type_validators.isValidUID)(str)) {
+        return { type: "UID", value: str, textValue: str };
+      }
+      return void 0;
+    }
+    case "SmartscapeId": {
+      const str = String(value);
+      if (parserConfig?.smartscapeIdConversion && (0, import_type_validators.isValidSmartscapeId)(str)) {
+        return { type: "SmartscapeId", value: str, textValue: str };
+      }
+      return void 0;
+    }
+  }
+}
+function inferLeaf(value, parserConfig) {
+  if (typeof value === "number") {
+    return { type: "Number", value };
+  }
+  if (typeof value === "boolean") {
+    return { type: "Boolean", value };
+  }
+  const durationMatch = DURATION_REGEX.exec(value);
+  if (durationMatch) {
+    return {
+      type: "Duration",
+      value: parseInt(durationMatch[1], 10),
+      unit: durationMatch[2].toLowerCase()
+    };
+  }
+  if (value === "true" || value === "false") {
+    return { type: "Boolean", value: value === "true" };
+  }
+  const parsedNumber = (0, import_getNumberParser.getNumberParser)().parse(value);
+  if (!isNaN(parsedNumber)) {
+    return { type: "Number", value: parsedNumber };
+  }
+  if (VARIABLE_REGEX.test(value)) {
+    return { type: "Variable", value, variableType: "Any" };
+  }
+  if (parserConfig?.ipAddressConversion && (0, import_type_validators.isValidIPAddress)(value)) {
+    return { type: "IPAddress", value, textValue: value };
+  }
+  if (parserConfig?.timestampConversion && (0, import_type_validators.isValidTimestamp)(value)) {
+    return { type: "Timestamp", value, textValue: value };
+  }
+  if (parserConfig?.uidConversion && (0, import_type_validators.isValidUID)(value)) {
+    return { type: "UID", value, textValue: value };
+  }
+  if (parserConfig?.smartscapeIdConversion && (0, import_type_validators.isValidSmartscapeId)(value)) {
+    return { type: "SmartscapeId", value, textValue: value };
+  }
+  return { type: "String", value };
+}
+function makeLeaf(value, parserConfig, valueType) {
+  if (valueType !== void 0) {
+    const typed = makeTypedLeaf(value, parserConfig, valueType);
+    if (typed !== void 0) {
+      return typed;
+    }
+  }
+  return inferLeaf(value, parserConfig);
+}
+function leafScalar(leaf) {
+  if (leaf.type === "Duration") {
+    return `${leaf.value}${leaf.unit}`;
+  }
+  const { value } = leaf;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  return void 0;
+}
+function leafEquals(leaf, value, options) {
+  const { valueType, parserConfig } = options ?? {};
+  if (!isExplicitValueType(valueType)) {
+    return leafValueMatches(leaf, value);
+  }
+  const candidate = makeLeaf(value, parserConfig, valueType);
+  if (leaf.type !== candidate.type) {
+    return false;
+  }
+  const candidateScalar = leafScalar(candidate);
+  return candidateScalar !== void 0 && leafScalar(leaf) === candidateScalar;
+}
+function leafValueMatches(leaf, value) {
   switch (leaf.type) {
     case "Number":
       if (typeof value === "number") {
@@ -141,29 +286,35 @@ function leafEquals(leaf, value) {
       return false;
   }
 }
-function findSearchStatement(group, value) {
+function findSearchStatement(group, value, options) {
   for (let i = group.children.length - 1; i >= 0; i--) {
     const child = group.children[i];
     if ((0, import_tree_node_guards.isFilterFieldGroupNode)(child)) {
-      const nested = findSearchStatement(child, value);
+      const nested = findSearchStatement(child, value, options);
       if (nested) {
         return nested;
       }
     } else if ((0, import_tree_node_guards.isFilterFieldStatementNode)(child)) {
       const op = child.comparisonOperator;
       const leafValue = child.value;
-      if (op?.type === "SearchOperator" && leafValue !== void 0 && !(0, import_tree_node_guards.isFilterFieldListNode)(leafValue) && leafEquals(leafValue, value)) {
+      if (op?.type === "SearchOperator" && leafValue !== void 0 && !(0, import_tree_node_guards.isFilterFieldListNode)(leafValue) && leafEquals(leafValue, value, options)) {
         return child;
       }
     }
   }
   return void 0;
 }
-function findIdenticalStatement(group, key, operatorNode, value) {
+function findIdenticalStatement(group, key, operatorNode, value, options) {
   for (let i = group.children.length - 1; i >= 0; i--) {
     const child = group.children[i];
     if ((0, import_tree_node_guards.isFilterFieldGroupNode)(child)) {
-      const nested = findIdenticalStatement(child, key, operatorNode, value);
+      const nested = findIdenticalStatement(
+        child,
+        key,
+        operatorNode,
+        value,
+        options
+      );
       if (nested) {
         return nested;
       }
@@ -180,7 +331,7 @@ function findIdenticalStatement(group, key, operatorNode, value) {
         return child;
       }
       const childValue = child.value;
-      if (childValue && !(0, import_tree_node_guards.isFilterFieldListNode)(childValue) && childValue.type !== "Error" && leafEquals(childValue, value)) {
+      if (childValue && !(0, import_tree_node_guards.isFilterFieldListNode)(childValue) && childValue.type !== "Error" && leafEquals(childValue, value, options)) {
         return child;
       }
     }

package/filters/index.d.ts

@@ -26,7 +26,7 @@ export { convertFilterFieldTreeToDql, enrichFilterFieldTreeWithDql, } from './fi
 export { escapeDqlIdentifier, escapeDqlStringLiteral, } from './filter-field/utils/conversion/dql-conversion/escape-dql.js';
 export { addFilter } from './filter-field/utils/value-operations/add-filter.js';
 export { removeFilter } from './filter-field/utils/value-operations/remove-filter.js';
-export type { FilterFieldValueOperationStatement, FilterFieldValueOperationResult, } from './filter-field/types/value-operations.js';
+export type { FilterFieldValueOperationStatement, FilterFieldValueOperationResult, FilterFieldKeyOnlyStatement, FilterFieldRemoveStatement, } from './filter-field/types/value-operations.js';
 export { FILTERFIELD_DEFAULT_OPERATORS } from './filter-field/utils/validation-utils/operator-specification.js';
 export { migrateFilterFieldKeyPredicatesToArray } from './filter-field/utils/migrate-validator-map.js';
 export { SegmentSelector } from './segment-selector/SegmentSelector.js';

package/filters/segment-selector/SegmentSelector.css

@@ -1,22 +1,22 @@
-._11m6jkl0-3-13-2 {
+._11m6jkl0-3-14-0 {
   all: unset;
   display: flex;
   flex-direction: column;
   gap: var(--dt-spacings-size-8, 8px);
 }
-._11m6jkl1-3-13-2 {
+._11m6jkl1-3-14-0 {
   all: unset;
   width: 100%;
   display: flex;
   flex-direction: column;
   gap: var(--dt-spacings-size-4, 4px);
 }
-._11m6jkl2-3-13-2 {
+._11m6jkl2-3-14-0 {
   max-height: 100px;
   overflow-y: auto;
   overflow-x: hidden;
   padding-right: var(--dt-spacings-size-12, 12px);
 }
-._11m6jkl3-3-13-2 > div {
+._11m6jkl3-3-14-0 > div {
   padding-right: var(--dt-spacings-size-0, 0);
 }

package/filters/segment-selector/SegmentSelector.js

@@ -63,6 +63,7 @@ var import_merge_props = require("../../core/utils/merge-props.js");
 var import_FormFieldMessageContextProvider = require("../../forms/forms-core/components/form-field/FormFieldMessageContextProvider.js");
 var import_useFormFieldValidation = require("../../forms/forms-core/hooks/useFormFieldValidation.js");
 var import_useContainerFocus = require("../../forms/hooks/useContainerFocus.js");
+var import_types = require("../../forms/validation/types.js");
 var import_useCustomMessageEmitter = require("../../forms/validation/useCustomMessageEmitter.js");
 var import_useValidationStateEmitter = require("../../forms/validation/useValidationStateEmitter.js");
 var import_validation_builders = require("../../forms/validation/validation-builders.js");
@@ -174,12 +175,13 @@ const SegmentSelectorFwd = (0, import_react.forwardRef)((props, forwardedRef) =>
         type: import_formfield_messages_state_reducer.FormFieldMessagesAction.ADDMESSAGE,
         payload: {
           id: errorId,
-          variant: "error",
-          validityStateKey: "customError",
-          messageType: "formcontrol",
           showError: true,
-          message: intl.formatMessage(
-            import_segmentMessages.SEGMENTSELECTOR_MESSAGES.noReadAndWriteAccess
+          error: new import_types.ValidationError(
+            intl.formatMessage(import_segmentMessages.SEGMENTSELECTOR_MESSAGES.noReadAndWriteAccess),
+            {
+              source: "strato",
+              validityStateKey: import_types.NativeValidityStateKeys.customError
+            }
           )
         }
       });
@@ -188,14 +190,15 @@ const SegmentSelectorFwd = (0, import_react.forwardRef)((props, forwardedRef) =>
       segments,
       onChange,
       formFieldMessagesDispatch,
-      formFieldMessagesState.formControlMessages,
+      formFieldMessagesState.errors,
       errorId,
+      intl,
       true
     ).catch(() => void 0);
   }, [
     errorId,
     formFieldMessagesDispatch,
-    formFieldMessagesState.formControlMessages,
+    formFieldMessagesState.errors,
     intl,
     onChange,
     segments
@@ -264,8 +267,9 @@ const SegmentSelectorFwd = (0, import_react.forwardRef)((props, forwardedRef) =>
           segments,
           onChange,
           formFieldMessagesDispatch,
-          formFieldMessagesState.formControlMessages,
+          formFieldMessagesState.errors,
           errorId,
+          intl,
           true
         ).catch(() => void 0);
       }
@@ -341,13 +345,15 @@ const SegmentSelectorFwd = (0, import_react.forwardRef)((props, forwardedRef) =>
       segments,
       onChange,
       formFieldMessagesDispatch,
-      formFieldMessagesState.formControlMessages,
-      errorId
+      formFieldMessagesState.errors,
+      errorId,
+      intl
     ).catch(() => void 0);
   }, [
     errorId,
     formFieldMessagesDispatch,
-    formFieldMessagesState.formControlMessages,
+    formFieldMessagesState.errors,
+    intl,
     onChange,
     segments,
     stringifiedValue

package/filters/segment-selector/SegmentSelector.sty.js

@@ -24,7 +24,7 @@ __export(SegmentSelector_css_exports, {
 });
 module.exports = __toCommonJS(SegmentSelector_css_exports);
 var import_SegmentSelector_css_ts_vanilla = require("./SegmentSelector.css");
-var overwriteTooltipElementPadding = "_11m6jkl3-3-13-2";
-var segmentSelectorList = "_11m6jkl0-3-13-2";
-var segmentSelectorListItem = "_11m6jkl1-3-13-2";
-var tooltipMaxHeight = "_11m6jkl2-3-13-2";
+var overwriteTooltipElementPadding = "_11m6jkl3-3-14-0";
+var segmentSelectorList = "_11m6jkl0-3-14-0";
+var segmentSelectorListItem = "_11m6jkl1-3-14-0";
+var tooltipMaxHeight = "_11m6jkl2-3-14-0";

package/filters/segment-selector/contexts/SegmentsUI/segmentValidationHelper.d.ts

@@ -1,4 +1,5 @@
 import type { ChangeEvent, Dispatch } from 'react';
+import type { IntlShape } from 'react-intl';
 import type { Include } from '@dynatrace-sdk/client-filter-segment-management';
 import type { FilterSegment } from '@dynatrace-sdk/client-query';
 import type { SegmentSelectorUIState } from './SegmentsUIReducer.js';
@@ -30,5 +31,5 @@ export declare function areUiSegmentsValid(uiSegments?: SegmentSelectorUIState['
  * If they are no longer available it adds an error.
  * Similarly it removes the error if it no longer applies.
  */
-export declare function validateSegments(segments: FilterSegment[], onChange: (event?: ChangeEvent<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>) => void, formFieldMessagesDispatch: Dispatch<FormFieldMessagesReducerAction> | undefined, formControlMessages: FormFieldMessageContextState['formControlMessages'], errorId: string, showError?: boolean): Promise<void>;
+export declare function validateSegments(segments: FilterSegment[], onChange: (event?: ChangeEvent<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>) => void, formFieldMessagesDispatch: Dispatch<FormFieldMessagesReducerAction> | undefined, formControlErrors: FormFieldMessageContextState['errors'], errorId: string, intl: IntlShape, showError?: boolean): Promise<void>;
 //# sourceMappingURL=segmentValidationHelper.d.ts.map

package/filters/segment-selector/contexts/SegmentsUI/segmentValidationHelper.js

@@ -23,8 +23,6 @@ __export(segmentValidationHelper_exports, {
   validateSegments: () => validateSegments
 });
 module.exports = __toCommonJS(segmentValidationHelper_exports);
-var import_jsx_runtime = require("react/jsx-runtime");
-var import_react_intl = require("react-intl");
 var import_formfield_messages_state_reducer = require("../../../../forms/forms-core/state/formfield-messages-state-reducer.js");
 var import_types = require("../../../../forms/validation/types.js");
 var import_tree_node_guards = require("../../../filter-field/utils/tree-node-guards.js");
@@ -120,10 +118,10 @@ async function areUiSegmentsValid(uiSegments) {
   );
   return !hasError;
 }
-async function validateSegments(segments, onChange, formFieldMessagesDispatch, formControlMessages, errorId, showError = false) {
+async function validateSegments(segments, onChange, formFieldMessagesDispatch, formControlErrors, errorId, intl, showError = false) {
   onChange();
   const isValid = await areUiSegmentsValid(segments);
-  const hasFormControlError = formControlMessages.some(
+  const hasFormControlError = formControlErrors.some(
     (message) => message.id === errorId
   );
   if (hasFormControlError && (import_SegmentsCache.segmentsClient.hasAccessRights === false && segments.length === 0 || isValid)) {
@@ -131,7 +129,7 @@ async function validateSegments(segments, onChange, formFieldMessagesDispatch, f
       type: import_formfield_messages_state_reducer.FormFieldMessagesAction.REMOVEMESSAGE,
       payload: {
         id: errorId,
-        messageType: "formcontrol"
+        source: "strato"
       }
     });
     return;
@@ -141,14 +139,12 @@ async function validateSegments(segments, onChange, formFieldMessagesDispatch, f
       type: import_formfield_messages_state_reducer.FormFieldMessagesAction.ADDMESSAGE,
       payload: {
         id: errorId,
-        variant: "error",
-        validityStateKey: "customError",
-        messageType: "formcontrol",
         showError: true,
-        message: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-          import_react_intl.FormattedMessage,
+        error: new import_types.ValidationError(
+          intl.formatMessage(import_segmentMessages.SEGMENTSELECTOR_MESSAGES.noReadAndWriteAccess),
           {
-            ...import_segmentMessages.SEGMENTSELECTOR_MESSAGES.noReadAndWriteAccess
+            source: "strato",
+            validityStateKey: import_types.NativeValidityStateKeys.customError
           }
         )
       }
@@ -159,11 +155,14 @@ async function validateSegments(segments, onChange, formFieldMessagesDispatch, f
       type: import_formfield_messages_state_reducer.FormFieldMessagesAction.ADDMESSAGE,
       payload: {
         id: errorId,
-        variant: "error",
-        validityStateKey: "customError",
-        messageType: "formcontrol",
         showError: showError ? true : void 0,
-        message: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_intl.FormattedMessage, { ...import_segmentMessages.SEGMENTSELECTOR_MESSAGES.genericSegmentError })
+        error: new import_types.ValidationError(
+          intl.formatMessage(import_segmentMessages.SEGMENTSELECTOR_MESSAGES.genericSegmentError),
+          {
+            source: "strato",
+            validityStateKey: import_types.NativeValidityStateKeys.customError
+          }
+        )
       }
     });
   }

package/filters/segment-selector/parts/EmptySegments.css

@@ -1,4 +1,4 @@
-._awal5d0-3-13-2._awal5d0-3-13-2 {
+._awal5d0-3-14-0._awal5d0-3-14-0 {
   font-family: var(--dt-typography-text-base-emphasized-family, DynatraceFlow,Roboto,Helvetica,sans-serif);
   font-weight: var(--dt-typography-text-base-emphasized-weight, 500);
   font-size: var(--dt-typography-text-base-emphasized-size, 14px);

package/filters/segment-selector/parts/EmptySegments.sty.js

@@ -21,4 +21,4 @@ __export(EmptySegments_css_exports, {
 });
 module.exports = __toCommonJS(EmptySegments_css_exports);
 var import_EmptySegments_css_ts_vanilla = require("./EmptySegments.css");
-var AppLinkButtonCSS = "_awal5d0-3-13-2";
+var AppLinkButtonCSS = "_awal5d0-3-14-0";