@dynatrace/strato-components 3.12.2 → 3.13.0

package/filters/filter-field/utils/conversion/dql-conversion/statement-to-dql-fragments.js

@@ -106,6 +106,52 @@ function buildDqlPattern(rawValue, operator, wildcard) {
       return `"${escapedValue}"`;
   }
 }
+function buildWildcardMatchContent(rawValue, textValue) {
+  const textContent = textValue?.replace(/(?<!\\)"/g, "");
+  if (!textContent?.includes("\\*")) {
+    return { content: (0, import_escape_dql.escapeDqlStringContent)(rawValue), wildcardArgument: "" };
+  }
+  const parts = [];
+  let textIdx = 0;
+  let rawIdx = 0;
+  while (textIdx < textContent.length) {
+    if (textContent[textIdx] === "\\" && textIdx + 1 < textContent.length) {
+      if (textContent[textIdx + 1] === "*") {
+        parts.push("*");
+      } else {
+        parts.push((0, import_escape_dql.escapeDqlStringContent)(rawValue[rawIdx]));
+      }
+      textIdx += 2;
+      rawIdx += 1;
+    } else if (textContent[textIdx] === "*") {
+      parts.push(DQL_LITERAL_ASTERISK_WILDCARD);
+      textIdx++;
+      rawIdx++;
+    } else {
+      const startRaw = rawIdx;
+      while (textIdx < textContent.length && textContent[textIdx] !== "*" && textContent[textIdx] !== "\\") {
+        textIdx++;
+        rawIdx++;
+      }
+      parts.push((0, import_escape_dql.escapeDqlStringContent)(rawValue.slice(startRaw, rawIdx)));
+    }
+  }
+  return {
+    content: parts.join(""),
+    wildcardArgument: `, wildcard: "${DQL_LITERAL_ASTERISK_WILDCARD}"`
+  };
+}
+function buildMatchesWildcardFragment(key, operator, value) {
+  if (value.type !== "String") {
+    return null;
+  }
+  const { content, wildcardArgument } = buildWildcardMatchContent(
+    value.value,
+    value.textValue
+  );
+  const fragment = `matchesValue(${key}, "${content}"${wildcardArgument})`;
+  return operator === "not-matches-wildcard" ? `not ${fragment}` : fragment;
+}
 function buildStringFragment(key, operator, value) {
   if (RELATIONAL_OPERATORS.has(operator)) {
     return `${key} ${operator} ${(0, import_escape_dql.escapeDqlStringLiteral)(value)}`;
@@ -161,20 +207,26 @@ function buildInclusionFragment(key, operator, value) {
   }
   return operator === "not in" ? `not ${fragment}` : fragment;
 }
+function buildMatchesPhraseFragment(key, operator, value) {
+  const phrase = getTextValue(value);
+  if (phrase === null) {
+    return null;
+  }
+  const wildcardArgument = getWildcardArgument(phrase);
+  const fragment = `matchesPhrase(${key}, ${(0, import_escape_dql.escapeDqlStringLiteral)(
+    phrase
+  )}${wildcardArgument})`;
+  return operator === "not-matches-phrase" ? `not ${fragment}` : fragment;
+}
 function buildComparisonFragment(key, operator, value) {
   if (!isSingleValue(value)) {
     return null;
   }
   if (operator === "matches-phrase" || operator === "not-matches-phrase") {
-    const phrase = getTextValue(value);
-    if (phrase === null) {
-      return null;
-    }
-    const wildcardArgument = getWildcardArgument(phrase);
-    const fragment = `matchesPhrase(${key}, ${(0, import_escape_dql.escapeDqlStringLiteral)(
-      phrase
-    )}${wildcardArgument})`;
-    return operator === "not-matches-phrase" ? `not ${fragment}` : fragment;
+    return buildMatchesPhraseFragment(key, operator, value);
+  }
+  if (operator === "matches-wildcard" || operator === "not-matches-wildcard") {
+    return buildMatchesWildcardFragment(key, operator, value);
   }
   if (value.type === "String") {
     return buildStringFragment(key, operator, value.value);

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

@@ -61,7 +61,8 @@ function convertInclusionValue(node, doc, numberParser, customTypes, parserConfi
         const {
           convertedNode: valueNode,
           errors: valueErrors,
-          positionOperators
+          positionOperators,
+          wildcardInMiddle
         } = (0, import_simple_value.convertSimpleValue)(
           childNode,
           doc,
@@ -69,9 +70,12 @@ function convertInclusionValue(node, doc, numberParser, customTypes, parserConfi
           customTypes,
           parserConfig
         );
-        if (positionOperators) {
+        if (positionOperators || wildcardInMiddle) {
           (0, import_node_mutations.convertToErrorNode)(valueNode);
-          for (const range of positionOperators.ranges) {
+          for (const range of [
+            ...positionOperators?.ranges ?? [],
+            ...wildcardInMiddle ?? []
+          ]) {
             errors.push({
               range,
               message: "invalidWildCardOperatorInList"

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

@@ -191,6 +191,33 @@ function validateKey(key, internalValidatorMap, errors = []) {
     });
   }
 }
+function convertWildcardInMiddle(convertedStatement, internalValidatorMap, wildcardRanges, errors, parserConfig) {
+  if (!convertedStatement.comparisonOperator) {
+    return;
+  }
+  const operator = convertedStatement.comparisonOperator;
+  const value = operator.value;
+  if (value !== "=" && value !== "!=") {
+    (0, import_node_mutations.convertToErrorNode)(convertedStatement.value);
+    for (const range of wildcardRanges) {
+      errors.push({ range, message: "invalidPositionOperator" });
+    }
+    return;
+  }
+  const newValue = value === "!=" ? "not-matches-wildcard" : "matches-wildcard";
+  convertedStatement.comparisonOperator.value = newValue;
+  if (!(0, import_validation_helper_functions.isValidOperator)(
+    newValue,
+    convertedStatement.key?.textValue,
+    internalValidatorMap,
+    parserConfig
+  )) {
+    (0, import_node_mutations.convertToErrorNode)(convertedStatement.value);
+    for (const range of wildcardRanges) {
+      errors.push({ range, message: "invalidWildCardOperator" });
+    }
+  }
+}
 function convertFilterStatement(node, doc, numberParser, internalValidatorMap, customTypes, parserConfig, context) {
   const nodeName = node.name;
   const { from, to } = node;
@@ -204,6 +231,7 @@ function convertFilterStatement(node, doc, numberParser, internalValidatorMap, c
   };
   const errors = [];
   let positionOperators;
+  let wildcardInMiddle;
   let prevNode;
   function updatePreviousAndContinue(nodeName2) {
     prevNode = nodeName2;
@@ -252,7 +280,8 @@ function convertFilterStatement(node, doc, numberParser, internalValidatorMap, c
         const {
           convertedNode: value,
           errors: valueErrors,
-          positionOperators: valuePositionOperators
+          positionOperators: valuePositionOperators,
+          wildcardInMiddle: valueWildcardInMiddle
         } = (0, import_simple_value.convertSimpleValue)(
           childNode,
           doc,
@@ -263,7 +292,10 @@ function convertFilterStatement(node, doc, numberParser, internalValidatorMap, c
         );
         convertedStatement.value = value;
         errors.push(...valueErrors);
-        positionOperators = valuePositionOperators;
+        wildcardInMiddle = valueWildcardInMiddle;
+        if (!wildcardInMiddle || wildcardInMiddle?.length === 0) {
+          positionOperators = valuePositionOperators;
+        }
         return updatePreviousAndContinue(nodeName2);
       }
       case "FilterIncludesValue": {
@@ -367,9 +399,11 @@ function convertFilterStatement(node, doc, numberParser, internalValidatorMap, c
         }
         return updatePreviousAndContinue(nodeName2);
       default:
-        console.log(
-          `${doc.toString()} | Syntax node '${nodeName2}' is not yet handled in the statement conversion. Please make sure to handle all nodes accordingly.`
-        );
+        if ((0, import_is_node_environment.isDev)()) {
+          console.log(
+            `${doc.toString()} | Syntax node '${nodeName2}' is not yet handled in the statement conversion. Please make sure to handle all nodes accordingly.`
+          );
+        }
     }
     prevNode = nodeName2;
   });
@@ -382,6 +416,15 @@ function convertFilterStatement(node, doc, numberParser, internalValidatorMap, c
       parserConfig
     );
   }
+  if (convertedStatement.comparisonOperator && wildcardInMiddle?.length) {
+    convertWildcardInMiddle(
+      convertedStatement,
+      internalValidatorMap,
+      wildcardInMiddle,
+      errors,
+      parserConfig
+    );
+  }
   validateKeyAndValue(
     internalValidatorMap,
     convertedStatement,
@@ -391,7 +434,7 @@ function convertFilterStatement(node, doc, numberParser, internalValidatorMap, c
     parserConfig
   );
   const operator = convertedStatement.comparisonOperator;
-  if (operator && !positionOperators && (!(0, import_validation_helper_functions.isValidOperator)(
+  if (operator && !positionOperators && !wildcardInMiddle?.length && (!(0, import_validation_helper_functions.isValidOperator)(
     operator.textValue,
     convertedStatement.key?.value,
     internalValidatorMap,

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

@@ -40,6 +40,7 @@ function convertIdentifier(node, doc, context) {
   };
   let endsWithOperator;
   let startsWithOperator;
+  let embeddedWildcards = [];
   if (node.name === "String") {
     endsWithOperator = text.slice(1, 2) === "*" ? { from: from + 1, to: from + 2 } : void 0;
     const withoutQuotes = text.slice(1, text.length - 1);
@@ -48,8 +49,19 @@ function convertIdentifier(node, doc, context) {
       endsWithOperator ? 1 : 0,
       value.length - (startsWithOperator ? 1 : 0)
     );
+    const contentText = text.slice(1, -1);
+    const wildcardRangesInContent = (0, import_range_helpers.findSpecialCharsRanges)(
+      contentText,
+      from + 1,
+      ["*"]
+    );
+    embeddedWildcards = wildcardRangesInContent.filter(
+      (range) => (!endsWithOperator || range.from !== endsWithOperator.from) && (!startsWithOperator || range.from !== startsWithOperator.from)
+    );
+  }
+  if (node.name === "Identifier" || node.name === "Variable") {
+    embeddedWildcards = (0, import_range_helpers.findSpecialCharsRanges)(text, from, ["*"]);
   }
-  const embeddedWildcards = node.name === "Identifier" || node.name === "Variable" ? (0, import_range_helpers.findSpecialCharsRanges)(text, from, ["*"]) : [];
   return {
     convertedNode,
     errors: [],

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

@@ -10,5 +10,6 @@ import type { FilterFieldCustomTypes, PositionOperators } from '../../../../type
  */
 export declare function convertSimpleValue(node: SyntaxNodeRef, doc: string, numberParser: NumberFormatParser, customTypes?: FilterFieldCustomTypes, parserConfig?: FilterFieldProps['parserConfig'], allowedValueTypes?: string[]): ConvertedLezerNode<FilterFieldLeafNode, {
     positionOperators?: PositionOperators;
+    wildcardInMiddle?: Array<PositionOperators['ranges'][number]>;
 }>;
 //# sourceMappingURL=simple-value.d.ts.map

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

@@ -47,6 +47,7 @@ function convertSimpleValue(node, doc, numberParser, customTypes, parserConfig,
   const errors = [];
   let positionOperators;
   let positionOperatorsInsideString;
+  const wildcardInMiddleRanges = [];
   cursor.iterate((childNode) => {
     const { from: childFrom, to: childTo } = childNode;
     const nodeName = childNode.name;
@@ -65,24 +66,24 @@ function convertSimpleValue(node, doc, numberParser, customTypes, parserConfig,
           embeddedWildcards
         } = (0, import_identifier.convertIdentifier)(childNode, doc, nodeName);
         if (
-          // eslint-disable-next-line @typescript-eslint/no-deprecated
+          // oxlint-disable-next-line typescript/no-deprecated
           parserConfig?.ipAddressConversion && nodeName === "Identifier" && (0, import_type_validators.isValidIPAddress)(value)
         ) {
           convertedNode.type = "IPAddress";
         } else if (
-          // eslint-disable-next-line @typescript-eslint/no-deprecated
+          // oxlint-disable-next-line typescript/no-deprecated
           parserConfig?.timestampConversion && (nodeName === "Identifier" || nodeName === "String") && (0, import_type_validators.isValidTimestamp)(value)
         ) {
           convertedNode.type = "Timestamp";
         }
         if (
-          // eslint-disable-next-line @typescript-eslint/no-deprecated
+          // oxlint-disable-next-line typescript/no-deprecated
           parserConfig?.uidConversion && nodeName === "Identifier" && (0, import_type_validators.isValidUID)(value)
         ) {
           convertedNode.type = "UID";
         }
         if (
-          // eslint-disable-next-line @typescript-eslint/no-deprecated
+          // oxlint-disable-next-line typescript/no-deprecated
           parserConfig?.smartscapeIdConversion && nodeName === "Identifier" && (0, import_type_validators.isValidSmartscapeId)(value)
         ) {
           convertedNode.type = "SmartscapeId";
@@ -129,8 +130,38 @@ function convertSimpleValue(node, doc, numberParser, customTypes, parserConfig,
           }
         }
         for (const range of embeddedWildcards) {
-          (0, import_node_mutations.convertToErrorNode)(convertedNode);
-          errors.push({ range, message: "unsupportedPositionOperator" });
+          if (parserConfig?.matchesWildcardConversion) {
+            wildcardInMiddleRanges.push(range);
+          } else if (nodeName !== "String") {
+            (0, import_node_mutations.convertToErrorNode)(convertedNode);
+            errors.push({ range, message: "unsupportedPositionOperator" });
+          }
+        }
+        if (embeddedWildcards.length > 0) {
+          const firstEmbedded = embeddedWildcards[0];
+          const lastEmbedded = embeddedWildcards[embeddedWildcards.length - 1];
+          if (endsWithOperator && endsWithOperator.to === firstEmbedded.from) {
+            (0, import_node_mutations.convertToErrorNode)(convertedNode);
+            errors.push({
+              range: endsWithOperator,
+              message: "unsupportedPositionOperator"
+            });
+            errors.push({
+              range: firstEmbedded,
+              message: "unsupportedPositionOperator"
+            });
+          }
+          if (startsWithOperator && lastEmbedded.to === startsWithOperator.from) {
+            (0, import_node_mutations.convertToErrorNode)(convertedNode);
+            errors.push({
+              range: lastEmbedded,
+              message: "unsupportedPositionOperator"
+            });
+            errors.push({
+              range: startsWithOperator,
+              message: "unsupportedPositionOperator"
+            });
+          }
         }
         if (!isValidIdentifier || nodeName === "IncompleteString") {
           (0, import_node_mutations.convertToErrorNode)(convertedNode);
@@ -278,13 +309,67 @@ function convertSimpleValue(node, doc, numberParser, customTypes, parserConfig,
         message: "duplicatePositionOperator"
       });
     }
+    if (typeInsideString === "contains" && type === "starts-with") {
+      (0, import_node_mutations.convertToErrorNode)(convertedNode);
+      errors.push({
+        range: positionOperatorsInsideString.ranges[1],
+        message: "duplicatePositionOperator"
+      });
+      errors.push({
+        range: positionOperators.ranges[0],
+        message: "duplicatePositionOperator"
+      });
+    }
+    if (typeInsideString === "contains" && type === "ends-with") {
+      (0, import_node_mutations.convertToErrorNode)(convertedNode);
+      errors.push({
+        range: positionOperators.ranges[0],
+        message: "duplicatePositionOperator"
+      });
+      errors.push({
+        range: positionOperatorsInsideString.ranges[0],
+        message: "duplicatePositionOperator"
+      });
+    }
     if (typeInsideString === "ends-with" && type === "starts-with" || typeInsideString === "starts-with" && type === "ends-with") {
       combinedPositionOperators.type = "contains";
     }
   }
+  const consecutiveWildcard = /* @__PURE__ */ new Set();
+  for (let i = 0; i + 1 < wildcardInMiddleRanges.length; i++) {
+    if (wildcardInMiddleRanges[i].to === wildcardInMiddleRanges[i + 1].from) {
+      (0, import_node_mutations.convertToErrorNode)(convertedNode);
+      if (!consecutiveWildcard.has(i)) {
+        consecutiveWildcard.add(i);
+        errors.push({
+          range: wildcardInMiddleRanges[i],
+          message: "unsupportedPositionOperator"
+        });
+      }
+      if (!consecutiveWildcard.has(i + 1)) {
+        consecutiveWildcard.add(i + 1);
+        errors.push({
+          range: wildcardInMiddleRanges[i + 1],
+          message: "unsupportedPositionOperator"
+        });
+      }
+    }
+  }
+  if (wildcardInMiddleRanges.length > 0 && errors.length === 0) {
+    const hasLeading = combinedPositionOperators?.type === "ends-with" || combinedPositionOperators?.type === "contains";
+    const hasTrailing = combinedPositionOperators?.type === "starts-with" || combinedPositionOperators?.type === "contains";
+    convertedNode.value = (hasLeading ? "*" : "") + convertedNode.value + (hasTrailing ? "*" : "");
+    return {
+      convertedNode,
+      errors,
+      positionOperators: combinedPositionOperators,
+      wildcardInMiddle: wildcardInMiddleRanges
+    };
+  }
   return {
     convertedNode,
     errors,
-    positionOperators: errors.length === 0 ? combinedPositionOperators : void 0
+    positionOperators: errors.length === 0 ? combinedPositionOperators : void 0,
+    wildcardInMiddle: void 0
   };
 }

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

@@ -42,6 +42,12 @@ function getOperatorInfo(operatorValue, operatorType) {
       operatorInfo.textValue = "!=";
       operatorInfo.positionOperator = operatorValue.substring(4);
       break;
+    case "matches-wildcard":
+      operatorInfo.textValue = "=";
+      break;
+    case "not-matches-wildcard":
+      operatorInfo.textValue = "!=";
+      break;
     case "matches-phrase":
       operatorInfo.textValue = "~";
       break;
@@ -72,7 +78,8 @@ function getNestedValue({
   nodeType,
   isFreeText,
   positionOperator,
-  separator
+  separator,
+  preserveWildcards
 }) {
   let value = _value;
   if (value === void 0) {
@@ -111,8 +118,10 @@ function getNestedValue({
   );
   value = value.replaceAll(/\\/g, "\\\\");
   value = value.replaceAll(/"/g, '\\"');
-  const positionOperatorInValueRegex = /\*/g;
-  value = value.replaceAll(positionOperatorInValueRegex, "\\*");
+  if (!preserveWildcards) {
+    const positionOperatorInValueRegex = /\*/g;
+    value = value.replaceAll(positionOperatorInValueRegex, "\\*");
+  }
   const reservedCharactersRegex = /(?!^\$)(?<!\\)(?:\\\\)*[,()!<>="$:[\]~ ]|\\$/;
   if (reservedCharactersRegex.test(value) || wrapInQuotes) {
     return `"${value}"`;
@@ -179,12 +188,14 @@ function _convertFilterFieldTreeToString(tree = void 0, convertedString = "") {
       }
       if (value) {
         const val = value.type === "Duration" ? `${value.value}${value.unit}` : value.value;
+        const shouldPreserveWildcards = comparisonOperator?.value === "matches-wildcard" || comparisonOperator?.value === "not-matches-wildcard";
         const childValues = getNestedValue({
           value: val,
           textValue: value.textValue,
           nodeType: value.type,
           positionOperator: operatorInfo.positionOperator,
-          separator: ","
+          separator: ",",
+          preserveWildcards: shouldPreserveWildcards
         });
         if (value.type === "List" || value.type === "Error" && Array.isArray(val)) {
           statement = `${statement}(${childValues})`;

package/filters/filter-field/utils/escape-suggestion.js

@@ -35,9 +35,13 @@ function escapeSuggestion(value) {
   if (value.startsWith("$") && new RegExp(IS_VARIABLE_REGEX).exec(value)) {
     return value;
   }
-  const isSuggestionEscaped = new RegExp(/^"(?:[^"\\]|\\")*"$/).exec(value);
+  const isSuggestionEscaped = new RegExp(/^"(?:[^"\\]|\\.)*(?:"|\\")$/).exec(
+    value
+  );
   if (isSuggestionEscaped) {
-    return value;
+    const inner = value.slice(1, -1);
+    const escapedInner = inner.replace(/(?<!\\)(?:\\\\)*\*/g, "\\*");
+    return `"${escapedInner}"`;
   }
   const matches = new RegExp(NEEDS_ESCAPING_REGEX, "g").exec(value);
   if (matches) {

package/filters/filter-field/utils/get-suggestion-transaction.js

@@ -74,6 +74,7 @@ function getSuggestionTransaction(suggestionValue, range, shouldEscapeSuggestion
   let startsWithOperator = false;
   let endsWithOperator = false;
   let hasSpaceAfterQuotes = false;
+  let isWildcardOperatorSwitch = false;
   const followedByOpeningParenthesis = _isFollowedByOpeningBracket(
     editorState,
     head
@@ -94,9 +95,24 @@ function getSuggestionTransaction(suggestionValue, range, shouldEscapeSuggestion
     if (insertionStrategy === "replace-statement" || isExistsOperator && currentStatement.value && !followedByOpeningParenthesis || startsWithOperator) {
       nextSibling = nextStatement;
       replaceUntil = currentStatement.range.to;
+    } else if (isWildcardSuggestionWithValuePlaceholder && !isValueToken && range === void 0 && currentStatement.value) {
+      isWildcardOperatorSwitch = true;
+      nextSibling = nextStatement;
+      replaceUntil = currentStatement.value.range.to;
     }
     insertedValue = nextSibling || insertionStrategy === "insert" ? trimmedValue : appliedSuggestionValue;
     const containsOperator = startsWithOperator && endsWithOperator;
+    if (isWildcardOperatorSwitch && currentStatement.value) {
+      const leadingWildcard = suggestionValue.endsWith('*"');
+      const trailingWildcard = (trailing ?? "").endsWith('"*');
+      const wrappedValue = buildWildcardWrappedValue(
+        currentStatement.value.textValue,
+        leadingWildcard,
+        trailingWildcard
+      );
+      const operatorSign = suggestionValue.startsWith("!=") ? "!= " : "= ";
+      insertedValue = nextSibling ? `${operatorSign}${wrappedValue}` : `${operatorSign}${wrappedValue} `;
+    }
     if ((startsWithOperator || endsWithOperator) && insertionStrategy === "replace-token") {
       let { from, to } = {
         from: currentStatement.range.to,
@@ -212,7 +228,7 @@ function getSuggestionTransaction(suggestionValue, range, shouldEscapeSuggestion
   }
   insertionRange = getSortedRange(insertionRange);
   let anchor = insertionStrategy === "insert" ? head + insertedValue.length : Math.min(currentDocumentLength, insertionRange.from) + (nextSibling && !isLastListValue ? appliedSuggestionValue.length : insertedValue.length) + (insertionStrategy === "replace-token" ? +startsWithOperator : 0) + +hasSpaceAfterQuotes;
-  if (cursorBeforeTrailing || isWildcardSuggestionWithValuePlaceholder) {
+  if ((cursorBeforeTrailing || isWildcardSuggestionWithValuePlaceholder) && !isWildcardOperatorSwitch) {
     const trailingLength = trailing ? trailing.length : 0;
     anchor -= trailingLength + (autoEscapeSuggestion && !(isSuggestionWithWildcard || isWildcardSuggestionWithValuePlaceholder) ? 1 : 0);
   }
@@ -225,8 +241,9 @@ function getSuggestionTransaction(suggestionValue, range, shouldEscapeSuggestion
     },
     selection: {
       anchor,
-      // Select the value placeholder if inserting a wildcard suggestion with a placeholder
-      ...isWildcardSuggestionWithValuePlaceholder ? { head: anchor + 5 } : {}
+      // Select the value placeholder if inserting a wildcard suggestion with a placeholder.
+      // Skip when performing a wildcard operator switch — the value is already filled in.
+      ...!isWildcardOperatorSwitch && isWildcardSuggestionWithValuePlaceholder ? { head: anchor + 5 } : {}
       // 5 = 'value'.length;
     }
   };
@@ -269,6 +286,30 @@ function getSuggestionTransactionForInclusionOperatorSuggestion(suggestionValue,
     }
   };
 }
+function buildWildcardWrappedValue(textValue, leadingWildcard, trailingWildcard) {
+  let bare = textValue;
+  if (bare.startsWith('*"')) {
+    bare = `"${bare.slice(2)}`;
+  } else if (bare.startsWith("*")) {
+    bare = bare.slice(1);
+  }
+  if (bare.endsWith('*"')) {
+    bare = `${bare.slice(0, -2)}"`;
+  } else if (bare.endsWith("*")) {
+    bare = bare.slice(0, -1);
+  }
+  if (bare.startsWith('"') && bare.endsWith('"')) {
+    let content = bare.slice(1, -1);
+    if (content.startsWith("*")) {
+      content = content.slice(1);
+    }
+    if (content.endsWith("*")) {
+      content = content.slice(0, -1);
+    }
+    return `"${leadingWildcard ? "*" : ""}${content}${trailingWildcard ? "*" : ""}"`;
+  }
+  return `${leadingWildcard ? "*" : ""}${bare}${trailingWildcard ? "*" : ""}`;
+}
 function getSortedRange(range) {
   if (range.to < range.from) {
     return { from: range.to, to: range.from };

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

@@ -44,7 +44,7 @@ function getComparisonOperatorSuggestions(key, internalValidatorMap, parserConfi
     key,
     internalValidatorMap,
     parserConfig
-  );
+  ).filter((op) => op !== "matches-wildcard" && op !== "not-matches-wildcard");
   return operators.map((operator) => {
     const operatorWithDetails = operatorSuggestionsWithDetails[operator];
     const baseProps = {

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

@@ -45,6 +45,7 @@ var import_messages = require("../../messages.js");
 var suggestionStyles = __toESM(require("../../suggestions/Suggestion.sty.js"));
 var import_escape_suggestion = require("../escape-suggestion.js");
 var import_operator_specification = require("../validation-utils/operator-specification.js");
+const QUOTED_VALUE_REGEX = /^"((?:[^"\\]|\\.)*)" ?$/;
 function getNoMatchingSuggestion(valueType = "Any") {
   return {
     trailing: "",
@@ -104,7 +105,7 @@ function getSearchSuggestion(value) {
       insertionStrategy: "replace-statement"
     };
   }
-  const match = /^"(.+)(?<!\\)" ?$/.exec(value);
+  const match = QUOTED_VALUE_REGEX.exec(value);
   const textValue = match ? match[1] : value;
   const escapedSuggestion = (0, import_escape_suggestion.escapeSuggestion)(match ? value.trim() : value);
   return {
@@ -127,7 +128,7 @@ function getSearchSuggestion(value) {
   };
 }
 function getFallbackKeySuggestion(key, operator, value) {
-  const match = /^"(.+)(?<!\\)" ?$/.exec(value);
+  const match = QUOTED_VALUE_REGEX.exec(value);
   const textValue = match ? match[1] : value;
   const escapedSuggestion = (0, import_escape_suggestion.escapeSuggestion)(match ? value.trim() : value);
   const baseOperator = operator.includes("not") ? "!=" : "=";
@@ -214,7 +215,7 @@ function getFallbackKeySuggestion(key, operator, value) {
   }
 }
 function getStatementSuggestionForMatchingValue(key, value) {
-  const match = /^"(.+)(?<!\\)" ?$/.exec(value);
+  const match = QUOTED_VALUE_REGEX.exec(value);
   const textValue = match ? match[1] : value;
   const escapedSuggestion = (0, import_escape_suggestion.escapeSuggestion)(match ? value.trim() : value);
   return {

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

@@ -147,6 +147,9 @@ function getDefaultValueOrWildcardSuggestion(textValue, value, internalValidator
       return isValidOperator ? [getNotEndsWithValueSuggestion(textValue, value)] : [getEndsWithIsNotSupportedSuggestion()];
     case "not-contains":
       return isValidOperator ? [getNotContainsValueSuggestion(textValue, value)] : [getContainsIsNotSupportedSuggestion()];
+    case "matches-wildcard":
+    case "not-matches-wildcard":
+      return isValidOperator ? [getMatchesWildcardValueSuggestion(textValue)] : [getMatchesWildcardIsNotSupportedSuggestion()];
     default: {
       if (textValue && typeof comparisonOperator !== "boolean") {
         return [getDefaultValueSuggestion(textValue)];
@@ -434,3 +437,42 @@ function getNotContainsValueSuggestion(textValue, value, valueType = "Any") {
     escapeSuggestion: false
   };
 }
+function getMatchesWildcardIsNotSupportedSuggestion(valueType = "Any") {
+  return {
+    trailing: "",
+    valueType,
+    suggestionType: "hint-wildcard",
+    id: "strato-filterfield-suggestion-matches-wildcard-not-supported",
+    displayValue: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_react_intl.FormattedMessage,
+      {
+        ...import_messages.filterFieldMessages.unsupportedOperators.matchesWildcard
+      }
+    )
+  };
+}
+function getMatchesWildcardValueSuggestion(textValue, valueType = "Any") {
+  const match = /^"(.+)(?<!\\)"$/.exec(textValue);
+  const displayText = match ? match[1] : textValue;
+  return {
+    trailing: " ",
+    value: textValue,
+    valueType,
+    suggestionType: "hint-wildcard",
+    id: "strato-filterfield-suggestion-matches-wildcard-value",
+    displayValue: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_react_intl.FormattedMessage,
+      {
+        ...import_messages.filterFieldMessages.value.matchesWildcard,
+        values: {
+          value: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+            "\xA0",
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("mark", { children: displayText }),
+            "\xA0"
+          ] })
+        }
+      }
+    ),
+    escapeSuggestion: false
+  };
+}