@dynatrace/strato-components 3.12.2 → 3.13.2

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../../src/filters/filter-field/utils/conversion/lezer-tree-conversion/value/simple-value.ts"],
-  "sourcesContent": ["import type { SyntaxNodeRef } from '@lezer/common';\n\nimport { convertBoolean } from './boolean.js';\nimport { convertDuration } from './duration.js';\nimport { convertIdentifier } from './identifier.js';\nimport { convertNumber } from './number.js';\nimport { isDev } from '../../../../../../core/utils/is-node-environment.js';\nimport type { FilterFieldProps } from '../../../../FilterField.types.js';\nimport type { NumberFormatParser } from '../../../../parser/getNumberParser.js';\nimport type { ConvertedLezerNode } from '../../../../types/conversion-utils.js';\nimport type { FilterFieldError } from '../../../../types/filter-field-error.js';\nimport type {\n  FilterFieldLeafNode,\n  FilterFieldLezerNodeType,\n  FilterFieldVariableNode,\n} from '../../../../types/tree-nodes.js';\nimport type {\n  FilterFieldCustomTypes,\n  PositionOperators,\n} from '../../../../types/validation.js';\nimport { getTextFromRange } from '../../../get-text.js';\nimport {\n  isValidIPAddress,\n  isValidSmartscapeId,\n  isValidTimestamp,\n  isValidUID,\n} from '../../../validation-utils/type-validators.js';\nimport { isValidCustomType } from '../../../validation-utils/validation-helper-functions.js';\nimport { convertNode } from '../generic-node.js';\nimport { convertToErrorNode, updateNodeValues } from '../node-mutations.js';\nimport { findSpecialCharsRanges } from '../utils/range-helpers.js';\n\n/**\n * Convert a simple value node.\n * @internal\n */\nexport function convertSimpleValue(\n  node: SyntaxNodeRef,\n  doc: string,\n  numberParser: NumberFormatParser,\n  customTypes?: FilterFieldCustomTypes,\n  parserConfig?: FilterFieldProps['parserConfig'],\n  allowedValueTypes?: string[],\n): ConvertedLezerNode<\n  FilterFieldLeafNode,\n  { positionOperators?: PositionOperators }\n> {\n  const { from, to } = node;\n  const cursor = node.node.cursor();\n\n  let convertedNode: FilterFieldLeafNode = {\n    type: 'String',\n    range: {\n      from,\n      to,\n    },\n    textValue: '',\n    value: '',\n    // With the type defaulting to 'String', typescript would infer a 'FilterFieldStringNode'.\n  } as FilterFieldLeafNode;\n  const errors: FilterFieldError[] = [];\n  let positionOperators: PositionOperators | undefined;\n  let positionOperatorsInsideString: PositionOperators | undefined;\n\n  cursor.iterate((childNode) => {\n    const { from: childFrom, to: childTo } = childNode;\n    const nodeName = childNode.name as FilterFieldLezerNodeType;\n    switch (nodeName) {\n      case 'FilterSimpleValue':\n      case 'ListValue':\n        // Intentionally left empty.\n        // Duplicating the tree cursor starts at the value node again.\n        break;\n      case 'Identifier':\n      case 'String':\n      case 'IncompleteString':\n      case 'Variable': {\n        const {\n          convertedNode: { textValue, value },\n          positionOperators: { endsWithOperator, startsWithOperator },\n          isValid: isValidIdentifier,\n          embeddedWildcards,\n        } = convertIdentifier(childNode, doc, nodeName);\n\n        if (\n          // eslint-disable-next-line @typescript-eslint/no-deprecated\n          parserConfig?.ipAddressConversion &&\n          nodeName === 'Identifier' &&\n          isValidIPAddress(value)\n        ) {\n          convertedNode.type = 'IPAddress';\n        } else if (\n          // eslint-disable-next-line @typescript-eslint/no-deprecated\n          parserConfig?.timestampConversion &&\n          (nodeName === 'Identifier' || nodeName === 'String') &&\n          isValidTimestamp(value)\n        ) {\n          convertedNode.type = 'Timestamp';\n        }\n\n        if (\n          // eslint-disable-next-line @typescript-eslint/no-deprecated\n          parserConfig?.uidConversion &&\n          nodeName === 'Identifier' &&\n          isValidUID(value)\n        ) {\n          convertedNode.type = 'UID';\n        }\n\n        if (\n          // eslint-disable-next-line @typescript-eslint/no-deprecated\n          parserConfig?.smartscapeIdConversion &&\n          nodeName === 'Identifier' &&\n          isValidSmartscapeId(value)\n        ) {\n          convertedNode.type = 'SmartscapeId';\n        }\n\n        const customType = isValidCustomType(value, customTypes);\n        if (customType) {\n          convertedNode.type = customType as never;\n        }\n\n        if (endsWithOperator || startsWithOperator) {\n          if (!positionOperatorsInsideString) {\n            positionOperatorsInsideString = { ranges: [] };\n          }\n\n          if (endsWithOperator) {\n            positionOperatorsInsideString.type = 'ends-with';\n            positionOperatorsInsideString.ranges.push(endsWithOperator);\n          }\n          if (startsWithOperator) {\n            positionOperatorsInsideString.type = 'starts-with';\n            positionOperatorsInsideString.ranges.push(startsWithOperator);\n          }\n          if (endsWithOperator && startsWithOperator) {\n            positionOperatorsInsideString.type = 'contains';\n            if (\n              endsWithOperator.from === startsWithOperator.from &&\n              endsWithOperator.to === startsWithOperator.to\n            ) {\n              convertToErrorNode(convertedNode);\n              errors.push({\n                range: positionOperatorsInsideString.ranges[0],\n                message: 'unsupportedPositionOperator',\n              });\n            }\n          }\n        }\n\n        updateNodeValues(convertedNode, textValue, value);\n\n        if (nodeName === 'Variable') {\n          convertedNode.type = 'Variable';\n          (convertedNode as FilterFieldVariableNode).variableType = 'Any';\n\n          // A Variable's leading `$` is the sigil; any additional `$` inside the\n          // Variable body is treated as a reserved-character error.\n          const embeddedDollarSigns = findSpecialCharsRanges(\n            textValue.slice(1),\n            childFrom + 1,\n            ['$'],\n          );\n          for (const range of embeddedDollarSigns) {\n            convertToErrorNode(convertedNode);\n            errors.push({ range, message: 'invalidCharacterInIdentifier' });\n          }\n        }\n\n        for (const range of embeddedWildcards) {\n          convertToErrorNode(convertedNode);\n          errors.push({ range, message: 'unsupportedPositionOperator' });\n        }\n\n        if (!isValidIdentifier || nodeName === 'IncompleteString') {\n          convertToErrorNode(convertedNode);\n        }\n\n        break;\n      }\n      case 'InvalidIdentifier': {\n        const {\n          convertedNode: { textValue },\n        } = convertNode(childNode, doc);\n        updateNodeValues(convertedNode, textValue);\n        convertToErrorNode(convertedNode);\n\n        break;\n      }\n      case 'Boolean': {\n        const textPrefix = convertedNode.textValue;\n        const { convertedNode: booleanNode } = convertBoolean(childNode, doc);\n        convertedNode = {\n          ...convertedNode,\n          ...booleanNode,\n          textValue: `${textPrefix ?? ''}${booleanNode.textValue}`,\n        };\n        break;\n      }\n      case 'Number': {\n        const { convertedNode: numberNode, embeddedCommas } = convertNumber(\n          childNode,\n          doc,\n          numberParser,\n        );\n        convertedNode = numberNode;\n        if (embeddedCommas.length > 0) {\n          if (allowedValueTypes?.includes('String')) {\n            convertedNode = {\n              ...convertedNode,\n              type: 'String',\n              value: convertedNode.textValue,\n            };\n          } else {\n            convertToErrorNode(convertedNode);\n            errors.push({\n              range: { from: childFrom, to: childTo },\n              message: 'invalidDecimalSeparatorInNumber',\n            });\n          }\n        }\n        break;\n      }\n      case 'Duration':\n        ({ convertedNode } = convertDuration(childNode, doc));\n        break;\n      case 'PositionOperator': {\n        const text = getTextFromRange(childNode, doc);\n        updateNodeValues(convertedNode, text, '');\n        if (!positionOperators) {\n          positionOperators = { ranges: [] };\n        }\n\n        const childRange = { from: childFrom, to: childTo };\n\n        if (childFrom === from) {\n          positionOperators.type = 'ends-with';\n          positionOperators.ranges.push(childRange);\n        } else if (childTo === to) {\n          positionOperators.type = positionOperators.type\n            ? 'contains'\n            : 'starts-with';\n          positionOperators.ranges.push(childRange);\n        }\n\n        break;\n      }\n      case 'InvalidPositionOperator': {\n        const text = getTextFromRange(childNode, doc);\n        updateNodeValues(convertedNode, text);\n        convertToErrorNode(convertedNode);\n\n        if (nodeName === 'InvalidPositionOperator') {\n          errors.push({\n            range: { from: childFrom, to: childTo },\n            message: 'unsupportedPositionOperator',\n          });\n        }\n\n        break;\n      }\n      case '\u26A0': {\n        // In case of an error, make sure the value is the same as the text value.\n        // e.g. 'foo = \\\\\\', before the error, the value is only '\\' (the escaped, second backslash).\n        // Adding the error node, the first backslash would be missing.\n        convertedNode.value = convertedNode.textValue;\n        convertToErrorNode(convertedNode);\n\n        return false;\n      }\n      default:\n        if (isDev()) {\n          // eslint-disable-next-line no-console\n          console.log(\n            `${doc.toString()} | Syntax node '${\n              childNode.name\n            }' is not yet handled in the simple value conversion. Please make sure to handle all nodes accordingly.`,\n          );\n        }\n    }\n  });\n\n  // Boolean keyword followed by a trailing position operator (e.g. true*) needs type promotion\n  // to String so that the value participates in starts-with/contains matching as a string.\n  if (positionOperators && convertedNode.type === 'Boolean') {\n    convertedNode = {\n      ...convertedNode,\n      type: 'String',\n      value: `${convertedNode.value}`,\n    };\n  }\n\n  if (convertedNode.type === 'Error') {\n    convertedNode.textValue = convertedNode.value = getTextFromRange(\n      convertedNode.range,\n      doc,\n    );\n    errors.push({\n      range: { from, to },\n      message: 'invalidValueErrorGeneric',\n    });\n  }\n\n  let combinedPositionOperators =\n    positionOperators ?? positionOperatorsInsideString;\n\n  // Position operators are currently supported outside and inside of doublequotes.\n  // If both are present, check if we have to show errors for invalid combinations.\n  if (positionOperators && positionOperatorsInsideString) {\n    combinedPositionOperators = {\n      ...positionOperators,\n      ranges: [\n        ...(positionOperators?.ranges ?? []),\n        ...(positionOperatorsInsideString?.ranges ?? []),\n      ],\n    };\n\n    const { type } = positionOperators;\n    const { type: typeInsideString } = positionOperatorsInsideString;\n\n    if (\n      // foo = *\"*bar\" | foo = *\"*bar\"*\n      (typeInsideString === 'ends-with' &&\n        (type === 'ends-with' || type === 'contains')) ||\n      // foo = \"bar*\"* | foo = *\"bar*\"*\n      (typeInsideString === 'starts-with' &&\n        (type === 'starts-with' || type === 'contains')) ||\n      // foo = *\"*bar*\"*\n      (typeInsideString === 'contains' && type === 'contains')\n    ) {\n      convertToErrorNode(convertedNode);\n      errors.push({\n        range: positionOperatorsInsideString.ranges[0],\n        message: 'duplicatePositionOperator',\n      });\n      errors.push({\n        range: positionOperators.ranges[0],\n        message: 'duplicatePositionOperator',\n      });\n    }\n\n    // foo = *\"*bar*\"*\n    if (typeInsideString === 'contains' && type === 'contains') {\n      convertToErrorNode(convertedNode);\n      errors.push({\n        range: positionOperatorsInsideString.ranges[1],\n        message: 'duplicatePositionOperator',\n      });\n      errors.push({\n        range: positionOperators.ranges[1],\n        message: 'duplicatePositionOperator',\n      });\n    }\n\n    // foo = \"*bar\"* || foo = *\"bar*\"\n    if (\n      (typeInsideString === 'ends-with' && type === 'starts-with') ||\n      (typeInsideString === 'starts-with' && type === 'ends-with')\n    ) {\n      combinedPositionOperators.type = 'contains';\n    }\n  }\n\n  return {\n    convertedNode,\n    errors,\n    positionOperators:\n      errors.length === 0 ? combinedPositionOperators : undefined,\n  };\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import type { SyntaxNodeRef } from '@lezer/common';\n\nimport { convertBoolean } from './boolean.js';\nimport { convertDuration } from './duration.js';\nimport { convertIdentifier } from './identifier.js';\nimport { convertNumber } from './number.js';\nimport { isDev } from '../../../../../../core/utils/is-node-environment.js';\nimport type { FilterFieldProps } from '../../../../FilterField.types.js';\nimport type { NumberFormatParser } from '../../../../parser/getNumberParser.js';\nimport type { ConvertedLezerNode } from '../../../../types/conversion-utils.js';\nimport type { FilterFieldError } from '../../../../types/filter-field-error.js';\nimport type {\n  FilterFieldLeafNode,\n  FilterFieldLezerNodeType,\n  FilterFieldVariableNode,\n} from '../../../../types/tree-nodes.js';\nimport type {\n  FilterFieldCustomTypes,\n  PositionOperators,\n} from '../../../../types/validation.js';\nimport { getTextFromRange } from '../../../get-text.js';\nimport {\n  isValidIPAddress,\n  isValidSmartscapeId,\n  isValidTimestamp,\n  isValidUID,\n} from '../../../validation-utils/type-validators.js';\nimport { isValidCustomType } from '../../../validation-utils/validation-helper-functions.js';\nimport { convertNode } from '../generic-node.js';\nimport { convertToErrorNode, updateNodeValues } from '../node-mutations.js';\nimport { findSpecialCharsRanges } from '../utils/range-helpers.js';\n\n/**\n * Convert a simple value node.\n * @internal\n */\nexport function convertSimpleValue(\n  node: SyntaxNodeRef,\n  doc: string,\n  numberParser: NumberFormatParser,\n  customTypes?: FilterFieldCustomTypes,\n  parserConfig?: FilterFieldProps['parserConfig'],\n  allowedValueTypes?: string[],\n): ConvertedLezerNode<\n  FilterFieldLeafNode,\n  {\n    positionOperators?: PositionOperators;\n    wildcardInMiddle?: Array<PositionOperators['ranges'][number]>;\n  }\n> {\n  const { from, to } = node;\n  const cursor = node.node.cursor();\n\n  let convertedNode: FilterFieldLeafNode = {\n    type: 'String',\n    range: {\n      from,\n      to,\n    },\n    textValue: '',\n    value: '',\n    // With the type defaulting to 'String', typescript would infer a 'FilterFieldStringNode'.\n  } as FilterFieldLeafNode;\n  const errors: FilterFieldError[] = [];\n  let positionOperators: PositionOperators | undefined;\n  let positionOperatorsInsideString: PositionOperators | undefined;\n  const wildcardInMiddleRanges: Array<PositionOperators['ranges'][number]> = [];\n\n  cursor.iterate((childNode) => {\n    const { from: childFrom, to: childTo } = childNode;\n    const nodeName = childNode.name as FilterFieldLezerNodeType;\n    switch (nodeName) {\n      case 'FilterSimpleValue':\n      case 'ListValue':\n        // Intentionally left empty.\n        // Duplicating the tree cursor starts at the value node again.\n        break;\n      case 'Identifier':\n      case 'String':\n      case 'IncompleteString':\n      case 'Variable': {\n        const {\n          convertedNode: { textValue, value },\n          positionOperators: { endsWithOperator, startsWithOperator },\n          isValid: isValidIdentifier,\n          embeddedWildcards,\n        } = convertIdentifier(childNode, doc, nodeName);\n\n        if (\n          // oxlint-disable-next-line typescript/no-deprecated\n          parserConfig?.ipAddressConversion &&\n          nodeName === 'Identifier' &&\n          isValidIPAddress(value)\n        ) {\n          convertedNode.type = 'IPAddress';\n        } else if (\n          // oxlint-disable-next-line typescript/no-deprecated\n          parserConfig?.timestampConversion &&\n          (nodeName === 'Identifier' || nodeName === 'String') &&\n          isValidTimestamp(value)\n        ) {\n          convertedNode.type = 'Timestamp';\n        }\n\n        if (\n          // oxlint-disable-next-line typescript/no-deprecated\n          parserConfig?.uidConversion &&\n          nodeName === 'Identifier' &&\n          isValidUID(value)\n        ) {\n          convertedNode.type = 'UID';\n        }\n\n        if (\n          // oxlint-disable-next-line typescript/no-deprecated\n          parserConfig?.smartscapeIdConversion &&\n          nodeName === 'Identifier' &&\n          isValidSmartscapeId(value)\n        ) {\n          convertedNode.type = 'SmartscapeId';\n        }\n\n        const customType = isValidCustomType(value, customTypes);\n        if (customType) {\n          convertedNode.type = customType as never;\n        }\n\n        if (endsWithOperator || startsWithOperator) {\n          if (!positionOperatorsInsideString) {\n            positionOperatorsInsideString = { ranges: [] };\n          }\n\n          if (endsWithOperator) {\n            positionOperatorsInsideString.type = 'ends-with';\n            positionOperatorsInsideString.ranges.push(endsWithOperator);\n          }\n          if (startsWithOperator) {\n            positionOperatorsInsideString.type = 'starts-with';\n            positionOperatorsInsideString.ranges.push(startsWithOperator);\n          }\n          if (endsWithOperator && startsWithOperator) {\n            positionOperatorsInsideString.type = 'contains';\n            if (\n              endsWithOperator.from === startsWithOperator.from &&\n              endsWithOperator.to === startsWithOperator.to\n            ) {\n              convertToErrorNode(convertedNode);\n              errors.push({\n                range: positionOperatorsInsideString.ranges[0],\n                message: 'unsupportedPositionOperator',\n              });\n            }\n          }\n        }\n\n        updateNodeValues(convertedNode, textValue, value);\n\n        if (nodeName === 'Variable') {\n          convertedNode.type = 'Variable';\n          (convertedNode as FilterFieldVariableNode).variableType = 'Any';\n\n          // A Variable's leading `$` is the sigil; any additional `$` inside the\n          // Variable body is treated as a reserved-character error.\n          const embeddedDollarSigns = findSpecialCharsRanges(\n            textValue.slice(1),\n            childFrom + 1,\n            ['$'],\n          );\n          for (const range of embeddedDollarSigns) {\n            convertToErrorNode(convertedNode);\n            errors.push({ range, message: 'invalidCharacterInIdentifier' });\n          }\n        }\n\n        for (const range of embeddedWildcards) {\n          // oxlint-disable-next-line typescript/no-deprecated\n          if (parserConfig?.matchesWildcardConversion) {\n            wildcardInMiddleRanges.push(range);\n          } else if (nodeName !== 'String') {\n            // Existing behavior: embedded wildcards in unquoted identifiers are errors.\n            // Wildcards inside quoted strings were silently ignored before, keep that behavior.\n            convertToErrorNode(convertedNode);\n            errors.push({ range, message: 'unsupportedPositionOperator' });\n          }\n        }\n\n        if (embeddedWildcards.length > 0) {\n          const firstEmbedded = embeddedWildcards[0];\n          const lastEmbedded = embeddedWildcards[embeddedWildcards.length - 1];\n\n          if (endsWithOperator && endsWithOperator.to === firstEmbedded.from) {\n            convertToErrorNode(convertedNode);\n            errors.push({\n              range: endsWithOperator,\n              message: 'unsupportedPositionOperator',\n            });\n            errors.push({\n              range: firstEmbedded,\n              message: 'unsupportedPositionOperator',\n            });\n          }\n\n          if (\n            startsWithOperator &&\n            lastEmbedded.to === startsWithOperator.from\n          ) {\n            convertToErrorNode(convertedNode);\n            errors.push({\n              range: lastEmbedded,\n              message: 'unsupportedPositionOperator',\n            });\n            errors.push({\n              range: startsWithOperator,\n              message: 'unsupportedPositionOperator',\n            });\n          }\n        }\n\n        if (!isValidIdentifier || nodeName === 'IncompleteString') {\n          convertToErrorNode(convertedNode);\n        }\n\n        break;\n      }\n      case 'InvalidIdentifier': {\n        const {\n          convertedNode: { textValue },\n        } = convertNode(childNode, doc);\n        updateNodeValues(convertedNode, textValue);\n        convertToErrorNode(convertedNode);\n\n        break;\n      }\n      case 'Boolean': {\n        const textPrefix = convertedNode.textValue;\n        const { convertedNode: booleanNode } = convertBoolean(childNode, doc);\n        convertedNode = {\n          ...convertedNode,\n          ...booleanNode,\n          textValue: `${textPrefix ?? ''}${booleanNode.textValue}`,\n        };\n        break;\n      }\n      case 'Number': {\n        const { convertedNode: numberNode, embeddedCommas } = convertNumber(\n          childNode,\n          doc,\n          numberParser,\n        );\n        convertedNode = numberNode;\n        if (embeddedCommas.length > 0) {\n          if (allowedValueTypes?.includes('String')) {\n            convertedNode = {\n              ...convertedNode,\n              type: 'String',\n              value: convertedNode.textValue,\n            };\n          } else {\n            convertToErrorNode(convertedNode);\n            errors.push({\n              range: { from: childFrom, to: childTo },\n              message: 'invalidDecimalSeparatorInNumber',\n            });\n          }\n        }\n        break;\n      }\n      case 'Duration':\n        ({ convertedNode } = convertDuration(childNode, doc));\n        break;\n      case 'PositionOperator': {\n        const text = getTextFromRange(childNode, doc);\n        updateNodeValues(convertedNode, text, '');\n        if (!positionOperators) {\n          positionOperators = { ranges: [] };\n        }\n\n        const childRange = { from: childFrom, to: childTo };\n\n        if (childFrom === from) {\n          positionOperators.type = 'ends-with';\n          positionOperators.ranges.push(childRange);\n        } else if (childTo === to) {\n          positionOperators.type = positionOperators.type\n            ? 'contains'\n            : 'starts-with';\n          positionOperators.ranges.push(childRange);\n        }\n\n        break;\n      }\n      case 'InvalidPositionOperator': {\n        const text = getTextFromRange(childNode, doc);\n        updateNodeValues(convertedNode, text);\n        convertToErrorNode(convertedNode);\n\n        if (nodeName === 'InvalidPositionOperator') {\n          errors.push({\n            range: { from: childFrom, to: childTo },\n            message: 'unsupportedPositionOperator',\n          });\n        }\n\n        break;\n      }\n      case '\u26A0': {\n        // In case of an error, make sure the value is the same as the text value.\n        // e.g. 'foo = \\\\\\', before the error, the value is only '\\' (the escaped, second backslash).\n        // Adding the error node, the first backslash would be missing.\n        convertedNode.value = convertedNode.textValue;\n        convertToErrorNode(convertedNode);\n\n        return false;\n      }\n      default:\n        if (isDev()) {\n          // oxlint-disable-next-line no-console\n          console.log(\n            `${doc.toString()} | Syntax node '${\n              childNode.name\n            }' is not yet handled in the simple value conversion. Please make sure to handle all nodes accordingly.`,\n          );\n        }\n    }\n  });\n\n  // Boolean keyword followed by a trailing position operator (e.g. true*) needs type promotion\n  // to String so that the value participates in starts-with/contains matching as a string.\n  if (positionOperators && convertedNode.type === 'Boolean') {\n    convertedNode = {\n      ...convertedNode,\n      type: 'String',\n      value: `${convertedNode.value}`,\n    };\n  }\n\n  if (convertedNode.type === 'Error') {\n    convertedNode.textValue = convertedNode.value = getTextFromRange(\n      convertedNode.range,\n      doc,\n    );\n    errors.push({\n      range: { from, to },\n      message: 'invalidValueErrorGeneric',\n    });\n  }\n\n  let combinedPositionOperators =\n    positionOperators ?? positionOperatorsInsideString;\n\n  // Position operators are currently supported outside and inside of doublequotes.\n  // If both are present, check if we have to show errors for invalid combinations.\n  if (positionOperators && positionOperatorsInsideString) {\n    combinedPositionOperators = {\n      ...positionOperators,\n      ranges: [\n        ...(positionOperators?.ranges ?? []),\n        ...(positionOperatorsInsideString?.ranges ?? []),\n      ],\n    };\n\n    const { type } = positionOperators;\n    const { type: typeInsideString } = positionOperatorsInsideString;\n\n    if (\n      // foo = *\"*bar\" | foo = *\"*bar\"*\n      (typeInsideString === 'ends-with' &&\n        (type === 'ends-with' || type === 'contains')) ||\n      // foo = \"bar*\"* | foo = *\"bar*\"*\n      (typeInsideString === 'starts-with' &&\n        (type === 'starts-with' || type === 'contains')) ||\n      // foo = *\"*bar*\"*\n      (typeInsideString === 'contains' && type === 'contains')\n    ) {\n      convertToErrorNode(convertedNode);\n      errors.push({\n        range: positionOperatorsInsideString.ranges[0],\n        message: 'duplicatePositionOperator',\n      });\n      errors.push({\n        range: positionOperators.ranges[0],\n        message: 'duplicatePositionOperator',\n      });\n    }\n\n    // foo = *\"*bar*\"*\n    if (typeInsideString === 'contains' && type === 'contains') {\n      convertToErrorNode(convertedNode);\n      errors.push({\n        range: positionOperatorsInsideString.ranges[1],\n        message: 'duplicatePositionOperator',\n      });\n      errors.push({\n        range: positionOperators.ranges[1],\n        message: 'duplicatePositionOperator',\n      });\n    }\n\n    // foo = \"*bar*\"* \u2014 trailing * inside adjacent to trailing * outside\n    if (typeInsideString === 'contains' && type === 'starts-with') {\n      convertToErrorNode(convertedNode);\n      errors.push({\n        range: positionOperatorsInsideString.ranges[1],\n        message: 'duplicatePositionOperator',\n      });\n      errors.push({\n        range: positionOperators.ranges[0],\n        message: 'duplicatePositionOperator',\n      });\n    }\n\n    // foo = *\"*bar*\" \u2014 leading * outside adjacent to leading * inside\n    if (typeInsideString === 'contains' && type === 'ends-with') {\n      convertToErrorNode(convertedNode);\n      errors.push({\n        range: positionOperators.ranges[0],\n        message: 'duplicatePositionOperator',\n      });\n      errors.push({\n        range: positionOperatorsInsideString.ranges[0],\n        message: 'duplicatePositionOperator',\n      });\n    }\n\n    // foo = \"*bar\"* || foo = *\"bar*\"\n    if (\n      (typeInsideString === 'ends-with' && type === 'starts-with') ||\n      (typeInsideString === 'starts-with' && type === 'ends-with')\n    ) {\n      combinedPositionOperators.type = 'contains';\n    }\n  }\n\n  // Consecutive wildcards (**) within an identifier are still errors even when\n  // wildcardInMiddleConversion is on \u2014 flag each wildcard that is adjacent to another.\n  const consecutiveWildcard = new Set<number>();\n  for (let i = 0; i + 1 < wildcardInMiddleRanges.length; i++) {\n    if (wildcardInMiddleRanges[i].to === wildcardInMiddleRanges[i + 1].from) {\n      convertToErrorNode(convertedNode);\n      if (!consecutiveWildcard.has(i)) {\n        consecutiveWildcard.add(i);\n        errors.push({\n          range: wildcardInMiddleRanges[i],\n          message: 'unsupportedPositionOperator',\n        });\n      }\n      if (!consecutiveWildcard.has(i + 1)) {\n        consecutiveWildcard.add(i + 1);\n        errors.push({\n          range: wildcardInMiddleRanges[i + 1],\n          message: 'unsupportedPositionOperator',\n        });\n      }\n    }\n  }\n\n  if (wildcardInMiddleRanges.length > 0 && errors.length === 0) {\n    // Restore any edge wildcards into the value so the full pattern is preserved,\n    // e.g. `*emea-*-prod*` \u2192 value = `*emea-*-prod*` (not `emea-*-prod`).\n    const hasLeading =\n      combinedPositionOperators?.type === 'ends-with' ||\n      combinedPositionOperators?.type === 'contains';\n    const hasTrailing =\n      combinedPositionOperators?.type === 'starts-with' ||\n      combinedPositionOperators?.type === 'contains';\n    convertedNode.value =\n      (hasLeading ? '*' : '') + convertedNode.value + (hasTrailing ? '*' : '');\n\n    return {\n      convertedNode,\n      errors,\n      positionOperators: combinedPositionOperators,\n      wildcardInMiddle: wildcardInMiddleRanges,\n    };\n  }\n\n  return {\n    convertedNode,\n    errors,\n    positionOperators:\n      errors.length === 0 ? combinedPositionOperators : undefined,\n    wildcardInMiddle: undefined,\n  };\n}\n"],
+  "mappings": "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",
   "names": []
 }

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/filters/filter-field/utils/conversion/tree-conversion.ts"],
-  "sourcesContent": ["import type { EditorView } from '@codemirror/view';\nimport type { Tree } from '@lezer/common';\n\nimport { sortFilterFieldTree } from './tree-precedence.js';\nimport { usedErrors } from '../../editor-state-configs/editor-config.js';\nimport type { FilterFieldProps } from '../../FilterField.types.js';\nimport type { NumberFormatParser } from '../../parser/getNumberParser.js';\nimport type { FilterFieldFlatGroupNode } from '../../types/conversion-utils.js';\nimport type { FilterFieldError } from '../../types/filter-field-error.js';\nimport type {\n  FilterFieldLezerNodeType,\n  FilterFieldRootNode,\n  FilterFieldTree,\n} from '../../types/tree-nodes.js';\nimport type { FilterFieldCustomTypes } from '../../types/validation.js';\nimport { convertFilterGroup } from './lezer-tree-conversion/parent-node/group.js';\nimport type { InternalValidatorMap } from '../../utils/validation-utils/normalize-validator-map.js';\n\n/**\n * Used parser version\n * @internal\n */\nexport const parserVersion = '004';\n\n/**\n * Iterate over the parsed document and convert the lezer tree to an object.\n * @internal\n */\nexport function convertLezerTree({\n  tree,\n  view,\n  numberParser,\n  doc,\n  internalValidatorMap,\n  customTypes,\n  parserConfig,\n}: {\n  tree: Tree;\n  numberParser: NumberFormatParser;\n  view?: EditorView;\n  doc?: string;\n  internalValidatorMap?: InternalValidatorMap;\n  customTypes?: FilterFieldCustomTypes;\n  parserConfig?: FilterFieldProps['parserConfig'];\n}): { tree?: FilterFieldTree; isValid: boolean; isValidSearch: boolean } {\n  const errorsStateField = view?.state.field(usedErrors, false);\n\n  if (!doc || doc === '') {\n    errorsStateField && (errorsStateField.errors = []);\n    return { isValid: true, isValidSearch: true };\n  }\n\n  const { tree: convertedFlatTree, errors: initialConversionErrors } =\n    convertFlatLezerTree({\n      tree,\n      numberParser,\n      doc,\n      internalValidatorMap,\n      customTypes,\n      parserConfig,\n    });\n\n  const {\n    tree: convertedTree,\n    errors: sortedTreeErrors,\n    isValidSearch,\n  } = sortFilterFieldTree(convertedFlatTree, parserConfig, doc);\n\n  const errors = [...initialConversionErrors, ...sortedTreeErrors];\n\n  if (errorsStateField) {\n    errors.sort((a, b) => (a.range.from < b.range.from ? -1 : 1));\n    errorsStateField.errors = errors;\n  }\n\n  if (convertedTree) {\n    (convertedTree as FilterFieldRootNode).version = '007';\n  }\n\n  return {\n    tree: convertedTree as FilterFieldTree,\n    isValid: errors.length === 0,\n    isValidSearch: isValidSearch ?? sortedTreeErrors,\n  };\n}\n\n/**\n * Iterate over the parsed document and convert the lezer tree to filter field nodes.\n * @internal\n */\nfunction convertFlatLezerTree({\n  tree,\n  numberParser,\n  doc,\n  internalValidatorMap,\n  customTypes,\n  parserConfig,\n}: Parameters<typeof convertLezerTree>[0]): {\n  tree?: FilterFieldFlatGroupNode | undefined;\n  errors: FilterFieldError[];\n} {\n  if (!doc || doc.toString() === '') {\n    return { errors: [] };\n  }\n\n  let convertedTree: FilterFieldFlatGroupNode = {\n    type: 'Group',\n    children: [],\n    range: { from: 0, to: tree.topNode.to },\n    logicalOperator: 'AND',\n    explicitLogicalOperator: false,\n    explicit: false,\n  };\n\n  const errors: FilterFieldError[] = [];\n\n  /**\n   * ATTENTION:\n   * When returning 'false' from the 'enter' callback, children of the respective node\n   * will not be iterated over. Also, the 'leave' callback will not be executed for the\n   * respective node. Hence, all cleanup (e.g. reducing the 'nestingLevel' again) must\n   * be performed when handling the node in the 'enter' callback.\n   */\n  tree.iterate({\n    from: tree.topNode.from,\n    to: tree.topNode.to,\n    enter: (_node) => {\n      const node = _node.node;\n\n      if ((node.name as FilterFieldLezerNodeType) === 'Filter') {\n        const { convertedNode, errors: groupErrors } = convertFilterGroup(\n          node,\n          doc,\n          numberParser,\n          internalValidatorMap,\n          customTypes,\n          parserConfig,\n          'Filter',\n        );\n        convertedTree = convertedNode;\n        errors.push(...groupErrors);\n\n        return false;\n      } else {\n        // eslint-disable-next-line no-console\n        console.log(\n          `${doc.toString()} | Syntax node '${\n            node.name\n          }' cannot be converted. Please make sure to handle all nodes accordingly.`,\n        );\n      }\n    },\n  });\n\n  const filter = {\n    tree: convertedTree,\n    errors,\n  };\n\n  return filter;\n}\n"],
+  "sourcesContent": ["import type { EditorView } from '@codemirror/view';\nimport type { Tree } from '@lezer/common';\n\nimport { sortFilterFieldTree } from './tree-precedence.js';\nimport { usedErrors } from '../../editor-state-configs/editor-config.js';\nimport type { FilterFieldProps } from '../../FilterField.types.js';\nimport type { NumberFormatParser } from '../../parser/getNumberParser.js';\nimport type { FilterFieldFlatGroupNode } from '../../types/conversion-utils.js';\nimport type { FilterFieldError } from '../../types/filter-field-error.js';\nimport type {\n  FilterFieldLezerNodeType,\n  FilterFieldRootNode,\n  FilterFieldTree,\n} from '../../types/tree-nodes.js';\nimport type { FilterFieldCustomTypes } from '../../types/validation.js';\nimport { convertFilterGroup } from './lezer-tree-conversion/parent-node/group.js';\nimport type { InternalValidatorMap } from '../../utils/validation-utils/normalize-validator-map.js';\n\n/**\n * Used parser version\n * @internal\n */\nexport const parserVersion = '004';\n\n/**\n * Iterate over the parsed document and convert the lezer tree to an object.\n * @internal\n */\nexport function convertLezerTree({\n  tree,\n  view,\n  numberParser,\n  doc,\n  internalValidatorMap,\n  customTypes,\n  parserConfig,\n}: {\n  tree: Tree;\n  numberParser: NumberFormatParser;\n  view?: EditorView;\n  doc?: string;\n  internalValidatorMap?: InternalValidatorMap;\n  customTypes?: FilterFieldCustomTypes;\n  parserConfig?: FilterFieldProps['parserConfig'];\n}): { tree?: FilterFieldTree; isValid: boolean; isValidSearch: boolean } {\n  const errorsStateField = view?.state.field(usedErrors, false);\n\n  if (!doc || doc === '') {\n    errorsStateField && (errorsStateField.errors = []);\n    return { isValid: true, isValidSearch: true };\n  }\n\n  const { tree: convertedFlatTree, errors: initialConversionErrors } =\n    convertFlatLezerTree({\n      tree,\n      numberParser,\n      doc,\n      internalValidatorMap,\n      customTypes,\n      parserConfig,\n    });\n\n  const {\n    tree: convertedTree,\n    errors: sortedTreeErrors,\n    isValidSearch,\n  } = sortFilterFieldTree(convertedFlatTree, parserConfig, doc);\n\n  const errors = [...initialConversionErrors, ...sortedTreeErrors];\n\n  if (errorsStateField) {\n    errors.sort((a, b) => (a.range.from < b.range.from ? -1 : 1));\n    errorsStateField.errors = errors;\n  }\n\n  if (convertedTree) {\n    (convertedTree as FilterFieldRootNode).version = '007';\n  }\n\n  return {\n    tree: convertedTree as FilterFieldTree,\n    isValid: errors.length === 0,\n    isValidSearch: isValidSearch ?? sortedTreeErrors,\n  };\n}\n\n/**\n * Iterate over the parsed document and convert the lezer tree to filter field nodes.\n * @internal\n */\nfunction convertFlatLezerTree({\n  tree,\n  numberParser,\n  doc,\n  internalValidatorMap,\n  customTypes,\n  parserConfig,\n}: Parameters<typeof convertLezerTree>[0]): {\n  tree?: FilterFieldFlatGroupNode | undefined;\n  errors: FilterFieldError[];\n} {\n  if (!doc || doc.toString() === '') {\n    return { errors: [] };\n  }\n\n  let convertedTree: FilterFieldFlatGroupNode = {\n    type: 'Group',\n    children: [],\n    range: { from: 0, to: tree.topNode.to },\n    logicalOperator: 'AND',\n    explicitLogicalOperator: false,\n    explicit: false,\n  };\n\n  const errors: FilterFieldError[] = [];\n\n  /**\n   * ATTENTION:\n   * When returning 'false' from the 'enter' callback, children of the respective node\n   * will not be iterated over. Also, the 'leave' callback will not be executed for the\n   * respective node. Hence, all cleanup (e.g. reducing the 'nestingLevel' again) must\n   * be performed when handling the node in the 'enter' callback.\n   */\n  tree.iterate({\n    from: tree.topNode.from,\n    to: tree.topNode.to,\n    enter: (_node) => {\n      const node = _node.node;\n\n      if ((node.name as FilterFieldLezerNodeType) === 'Filter') {\n        const { convertedNode, errors: groupErrors } = convertFilterGroup(\n          node,\n          doc,\n          numberParser,\n          internalValidatorMap,\n          customTypes,\n          parserConfig,\n          'Filter',\n        );\n        convertedTree = convertedNode;\n        errors.push(...groupErrors);\n\n        return false;\n      } else {\n        // oxlint-disable-next-line no-console\n        console.log(\n          `${doc.toString()} | Syntax node '${\n            node.name\n          }' cannot be converted. Please make sure to handle all nodes accordingly.`,\n        );\n      }\n    },\n  });\n\n  const filter = {\n    tree: convertedTree,\n    errors,\n  };\n\n  return filter;\n}\n"],
   "mappings": "AAGA,SAAS,2BAA2B;AACpC,SAAS,kBAAkB;AAW3B,SAAS,0BAA0B;AAO5B,MAAM,gBAAgB;AAMtB,SAAS,iBAAiB;AAAA,EAC/B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAQyE;AACvE,QAAM,mBAAmB,MAAM,MAAM,MAAM,YAAY,KAAK;AAE5D,MAAI,CAAC,OAAO,QAAQ,IAAI;AACtB,yBAAqB,iBAAiB,SAAS,CAAC;AAChD,WAAO,EAAE,SAAS,MAAM,eAAe,KAAK;AAAA,EAC9C;AAEA,QAAM,EAAE,MAAM,mBAAmB,QAAQ,wBAAwB,IAC/D,qBAAqB;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAEH,QAAM;AAAA,IACJ,MAAM;AAAA,IACN,QAAQ;AAAA,IACR;AAAA,EACF,IAAI,oBAAoB,mBAAmB,cAAc,GAAG;AAE5D,QAAM,SAAS,CAAC,GAAG,yBAAyB,GAAG,gBAAgB;AAE/D,MAAI,kBAAkB;AACpB,WAAO,KAAK,CAAC,GAAG,MAAO,EAAE,MAAM,OAAO,EAAE,MAAM,OAAO,KAAK,CAAE;AAC5D,qBAAiB,SAAS;AAAA,EAC5B;AAEA,MAAI,eAAe;AACjB,IAAC,cAAsC,UAAU;AAAA,EACnD;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS,OAAO,WAAW;AAAA,IAC3B,eAAe,iBAAiB;AAAA,EAClC;AACF;AAMA,SAAS,qBAAqB;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAGE;AACA,MAAI,CAAC,OAAO,IAAI,SAAS,MAAM,IAAI;AACjC,WAAO,EAAE,QAAQ,CAAC,EAAE;AAAA,EACtB;AAEA,MAAI,gBAA0C;AAAA,IAC5C,MAAM;AAAA,IACN,UAAU,CAAC;AAAA,IACX,OAAO,EAAE,MAAM,GAAG,IAAI,KAAK,QAAQ,GAAG;AAAA,IACtC,iBAAiB;AAAA,IACjB,yBAAyB;AAAA,IACzB,UAAU;AAAA,EACZ;AAEA,QAAM,SAA6B,CAAC;AASpC,OAAK,QAAQ;AAAA,IACX,MAAM,KAAK,QAAQ;AAAA,IACnB,IAAI,KAAK,QAAQ;AAAA,IACjB,OAAO,CAAC,UAAU;AAChB,YAAM,OAAO,MAAM;AAEnB,UAAK,KAAK,SAAsC,UAAU;AACxD,cAAM,EAAE,eAAe,QAAQ,YAAY,IAAI;AAAA,UAC7C;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF;AACA,wBAAgB;AAChB,eAAO,KAAK,GAAG,WAAW;AAE1B,eAAO;AAAA,MACT,OAAO;AAEL,gBAAQ;AAAA,UACN,GAAG,IAAI,SAAS,CAAC,mBACf,KAAK,IACP;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAC;AAED,QAAM,SAAS;AAAA,IACb,MAAM;AAAA,IACN;AAAA,EACF;AAEA,SAAO;AACT;",
   "names": []
 }

package/esm/filters/filter-field/utils/conversion/tree-precedence.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/filters/filter-field/utils/conversion/tree-precedence.ts"],
-  "sourcesContent": ["import Colors from '@dynatrace/strato-design-tokens/colors';\n\nimport type { FilterFieldError } from '../../types/filter-field-error.js';\nimport type {\n  FilterFieldGroupNode,\n  FilterFieldNode,\n  FilterFieldSearchOperatorNode,\n} from '../../types/tree-nodes.js';\nimport {\n  isFilterFieldStatementNode,\n  isLogicalOperator,\n} from '../tree-node-guards.js';\nimport { convertToErrorNode } from './lezer-tree-conversion/node-mutations.js';\nimport type { FilterFieldProps } from '../../FilterField.types.js';\nimport type {\n  FilterFieldFlatGroupNode,\n  FilterFieldFlatNode,\n  FilterFieldLogicalOperatorNode,\n} from '../../types/conversion-utils.js';\n\n/**\n * Iterate over the parsed document and convert the lezer tree to an object.\n * @internal\n */\nexport function sortFilterFieldTree(\n  tree: FilterFieldFlatGroupNode | undefined,\n  parserConfig: FilterFieldProps['parserConfig'],\n  doc?: string,\n): {\n  tree: FilterFieldGroupNode | undefined;\n  errors: FilterFieldError[];\n  isValidSearch: boolean;\n} {\n  if (!tree) {\n    return { tree, errors: [], isValidSearch: true };\n  }\n\n  const { tree: _cleanedTree, searchOperators } = groupByLogicalOperators({\n    tree,\n  });\n  let errors: FilterFieldError[] = [];\n\n  let cleanedTree = _cleanedTree;\n  let isValidSearch;\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (parserConfig?.searchConversion === true) {\n    ({\n      tree: cleanedTree,\n      errors,\n      isValidSearch,\n    } = checkValidSearchOperators(cleanedTree, searchOperators, doc));\n  }\n\n  return {\n    tree: cleanedTree,\n    errors,\n    isValidSearch: isValidSearch ?? false,\n  };\n}\n\ntype LogicalOperator = FilterFieldGroupNode['logicalOperator'];\n\n/**\n * Function to group the filter statements depending on the logical operators used.\n */\nfunction groupByLogicalOperators(\n  data: {\n    tree: FilterFieldFlatGroupNode;\n    searchOperators?: FilterFieldSearchOperatorNode[];\n  },\n  group?: FilterFieldGroupNode,\n): {\n  tree: FilterFieldGroupNode;\n  searchOperators: FilterFieldSearchOperatorNode[];\n} {\n  const { tree, searchOperators = [] } = data;\n  const sortedTree: FilterFieldGroupNode = group ?? {\n    type: 'Group',\n    range: tree.range,\n    logicalOperator: 'AND',\n    explicit: tree.explicit,\n    explicitLogicalOperator: false,\n    children: [],\n  };\n\n  let prevLogicalOperator: LogicalOperator | null | undefined;\n  let currentLogicalOperator: LogicalOperator | undefined | null;\n  let nestedTree: FilterFieldGroupNode | undefined;\n\n  // In case of an empty group, return an empty group.\n  if (\n    tree.type === 'Group' &&\n    (tree.children.length === 0 || tree.children[0].type === 'Error')\n  ) {\n    return {\n      tree: {\n        ...tree,\n        logicalOperator: 'AND',\n        explicitLogicalOperator: false,\n        children: tree.children as FilterFieldNode[],\n      },\n      searchOperators,\n    };\n  }\n\n  for (const [index, child] of tree.children.entries()) {\n    // push error nodes to the tree, except logical operators\n    // as they need to be handled separately\n    if (child.type === 'Error' && !isLogicalOperator(child)) {\n      (nestedTree ?? sortedTree).children.push(child);\n    }\n\n    if (\n      child.type === 'Statement' ||\n      (child.type === 'Group' && child.explicit)\n    ) {\n      const prevNode: FilterFieldFlatNode | undefined =\n        tree.children[index - 1];\n\n      if (\n        child.type === 'Statement' &&\n        child.comparisonOperator?.type === 'SearchOperator'\n      ) {\n        // Store search operator to potentially mark all of them as errors in a later step.\n        searchOperators.push(child.comparisonOperator);\n      }\n\n      prevLogicalOperator = currentLogicalOperator;\n      currentLogicalOperator = (\n        isLogicalOperator(prevNode)\n          ? // DEPRECATION: [APPDEV-13773] BREAKING-CHANGE: Exclude logical operator node from public tree type.\n            // Check how to best deal with the logical operator conversion here.\n\n            (prevNode as FilterFieldLogicalOperatorNode).value.toUpperCase()\n          : null\n      ) as FilterFieldGroupNode['logicalOperator'];\n\n      if (prevNode === undefined) {\n        currentLogicalOperator = undefined;\n      }\n\n      // In case the previous logical operator is not equal to the current, we need to group the\n      // previous statement and the current statement and nest them in the tree.\n      // An undefined logical operator indicates that there are no previous statements yet.\n      // E.g.:\n      /*\n        a = 1 OR b = 2 c = 2\n        tree before implicit and: { or: ['a = 1', 'b = 2' ]}\n        -> pop the last statement of the current tree and add it to a new nested\n           tree with the current statement\n        tree after implicit and:  { or: ['a = 1', { and: ['b = 2', 'c = 2]} ]}\n       */\n      const shouldCreateNestedTree =\n        prevLogicalOperator !== undefined &&\n        currentLogicalOperator !== undefined &&\n        currentLogicalOperator !== prevLogicalOperator &&\n        // For an explicit logical operator, a nested tree has already been created when handling the logical operator.\n        prevNode?.type !== 'LogicalOperator';\n\n      if (shouldCreateNestedTree) {\n        // Pop last node of previous tree.\n        const prevNode = sortedTree.children.pop();\n        if (!prevNode) {\n          continue;\n        }\n\n        let nestedChildren: FilterFieldNode;\n        if (child.type === 'Group') {\n          ({ tree: nestedChildren } = groupByLogicalOperators({\n            tree: child,\n            searchOperators,\n          }));\n        } else {\n          nestedChildren = child;\n        }\n\n        // Create new nested tree to push to the previous group.\n        const groupedChildren: FilterFieldNode[] = [prevNode, nestedChildren];\n\n        nestedTree = {\n          type: 'Group',\n          range: {\n            from: prevNode.range.from,\n            to: groupedChildren[groupedChildren.length - 1]?.range.to,\n          },\n          children: groupedChildren,\n          logicalOperator: currentLogicalOperator ?? 'AND',\n          explicitLogicalOperator:\n            currentLogicalOperator !== null &&\n            currentLogicalOperator !== undefined,\n          explicit: false,\n        };\n\n        sortedTree.children.push(nestedTree);\n\n        // Update the nested tree's range to include all of the new group if need be.\n        if (sortedTree.range.to < nestedTree.range.to) {\n          sortedTree.range.to = nestedTree.range.to;\n        }\n      } else {\n        let nestedChildren: FilterFieldNode;\n        if (child.type === 'Group') {\n          ({ tree: nestedChildren } = groupByLogicalOperators(\n            { tree: child, searchOperators },\n            // Pass the created nested tree for implicit groups only to avoid circular structures.\n            // The sorted tree returned at the end of the function is set to the 'group' parameter = nestedTree.\n            // If the child is an explicit group and we would pass the nestedTree, it would be pushed into the\n            // sortedTree of the previous recursion again when returning the current sortedTree.\n            child.explicit ? undefined : nestedTree,\n          ));\n        } else {\n          nestedChildren = child;\n        }\n\n        // If the current node is a group, recursively add the group to the tree.\n        (nestedTree ?? sortedTree).children.push(nestedChildren);\n\n        if (nestedTree) {\n          nestedTree.range.to = child.range.to;\n        }\n        if (!sortedTree.explicit && sortedTree.range.to < child.range.to) {\n          sortedTree.range.to = child.range.to;\n        }\n      }\n    }\n\n    // If the child is an explicit logical operator, depending on the previous\n    // logical operator, we either just push it to the current tree, or create\n    // a nested tree to group the relevant statements and logical operators.\n    // E.g.:\n    /*\n      a = 1 b = 1 OR c = 2\n      Once at the explicit 'OR', group the previous statements (a, b).\n\n      a = 1 OR b = 2 c = 2\n      Once at the implicit 'AND', group the previous statement\n      and the current statement (b, c).\n     */\n    if (isLogicalOperator(child)) {\n      // DEPRECATION: [APPDEV-13773] BREAKING-CHANGE: Exclude logical operator node from public tree type.\n      // Check how to best deal with the logical operator conversion here.\n\n      const convertedChild: FilterFieldLogicalOperatorNode =\n        child as FilterFieldLogicalOperatorNode;\n\n      prevLogicalOperator = currentLogicalOperator;\n      currentLogicalOperator =\n        convertedChild.value.toUpperCase() as FilterFieldGroupNode['logicalOperator'];\n\n      if (\n        prevLogicalOperator !== undefined &&\n        prevLogicalOperator !== currentLogicalOperator\n      ) {\n        if (\n          !nestedTree ||\n          (currentLogicalOperator === 'OR' &&\n            currentLogicalOperator !== sortedTree.logicalOperator &&\n            // Either of the trees has an explicit logical operator. The current logical operator does not match\n            // the operator of the sorted tree. We need to move the existing sorted tree to a nested tree.\n            (sortedTree.explicitLogicalOperator ||\n              nestedTree.explicitLogicalOperator ||\n              // Some deeper nested mixture of implicit and explicit logical and.\n              // With a current logical OR operator, we need to move the existing sorted tree to a nested tree.\n              sortedTree.logicalOperator === nestedTree.logicalOperator)) ||\n          // The current logical operator is an explicit AND with a previous implicit AND and logical OR.\n          // E.g.: b=2 OR c=3 d=4 AND e=5\n          // In this case, we already have a nested tree, but still have to create a new one to group\n          // The implicit and explicit logical AND while not losing the logical OR.\n          (sortedTree.logicalOperator === 'OR' &&\n            currentLogicalOperator === 'AND')\n        ) {\n          // Create a new nested tree.\n          nestedTree = {\n            type: 'Group',\n            logicalOperator: 'AND',\n            range: { from: -1, to: -1 },\n            explicit: false,\n            explicitLogicalOperator:\n              currentLogicalOperator === 'AND' ||\n              (currentLogicalOperator === 'OR' &&\n                sortedTree.explicitLogicalOperator),\n            children: [],\n          };\n\n          // Add all the previous nodes to the new tree until we get to an explicit\n          // logical operator 'OR' operator.\n          // E.g.:\n          /*\n            a = 1 AND b = 1 c = 1 OR d = 2 e = 2\n            Once at the logical 'OR', create a new nested tree to group all the previous statements\n            that are connected with 'AND'.\n            All of them need to be removed from the current tree and pushed to the nested tree.\n\n            a = 1 OR b = 2 AND c = 2\n            Once at the logical 'AND', create a new nested tree, but only include the previous statement (b)\n            and don't move anything before.\n\n            a = 1 b = 2 AND c = 2\n            Once at the logical 'AND', create a new nested tree, but only include the previous statement (b)\n            and don't move anything before to be able to distinguish between explicit and implicit logical and.\n           */\n          let abortGrouping = false;\n          do {\n            const previousNode = sortedTree.children.pop();\n            // Nothing left in the tree -> break;\n            if (!previousNode) {\n              break;\n            }\n\n            nestedTree.children.push(previousNode);\n\n            // If the previous node is a logical 'OR' operator or the sorted tree does not have an explicit logical operator, but\n            // the current logical operator is an explicit 'AND', stop pushing nodes to the nested tree.\n            if (\n              // Switching from logical and to logical or.\n              (sortedTree.explicitLogicalOperator &&\n                sortedTree.logicalOperator === 'OR') ||\n              // Mixture of implicit and explicit logical and.\n              (!sortedTree.explicitLogicalOperator &&\n                currentLogicalOperator === 'AND')\n            ) {\n              abortGrouping = true;\n            }\n          } while (!abortGrouping);\n\n          // Reverse the nested tree to restore the original order of the nodes.\n          nestedTree.children.reverse();\n\n          // Set the start and end index of the nested tree.\n          nestedTree.range.from = nestedTree.children[0]?.range.from;\n          nestedTree.range.to =\n            nestedTree.children[nestedTree.children.length - 1]?.range.to;\n\n          if (\n            currentLogicalOperator === 'AND' &&\n            nestedTree.range.to < child.range.to\n          ) {\n            nestedTree.range.to = child.range.to;\n          }\n\n          if (!nestedTree.children[0]) {\n            nestedTree = undefined;\n          } else {\n            // Push the nested tree to the current tree.\n            sortedTree.children.push(nestedTree);\n            if (currentLogicalOperator === 'OR') {\n              sortedTree.logicalOperator = currentLogicalOperator;\n            }\n          }\n        }\n\n        if (\n          currentLogicalOperator === 'OR' ||\n          (nestedTree?.explicitLogicalOperator === false &&\n            currentLogicalOperator === 'AND')\n        ) {\n          nestedTree = undefined;\n        }\n      } else {\n        (nestedTree ?? sortedTree).explicitLogicalOperator =\n          child.type !== 'Error';\n      }\n\n      // Add the logical operator node to the tree if it is an error node\n      if (child.type === 'Error') {\n        (nestedTree ?? sortedTree).children.push(child);\n      }\n\n      if (!nestedTree) {\n        if (!prevLogicalOperator) {\n          sortedTree.logicalOperator = currentLogicalOperator;\n        }\n\n        if (currentLogicalOperator && child.type !== 'Error') {\n          sortedTree.explicitLogicalOperator = true;\n        }\n        if (sortedTree.range.to < child.range.to) {\n          sortedTree.range.to = child.range.to;\n        }\n      }\n    }\n\n    if (\n      child.type === 'Error' &&\n      (child.value === 'OR' || child.value === 'AND')\n    ) {\n      (nestedTree ?? sortedTree).explicitLogicalOperator = false;\n    }\n  }\n\n  return { tree: sortedTree, searchOperators };\n}\n\n/**\n * Function to check whether search operators are only used in a valid context.\n * A combination of logical or with statements other than search statements is not allowed.\n * Due to the higher precedence of logical and, it is sufficient to check only the root level of the tree\n * and only if the root node's logical operator is a logical or.\n */\nfunction checkValidSearchOperators(\n  root: FilterFieldGroupNode,\n  searchOperators?: FilterFieldSearchOperatorNode[],\n  doc?: string,\n): {\n  tree: FilterFieldGroupNode;\n  errors: FilterFieldError[];\n  isValidSearch: boolean;\n} {\n  const errors: FilterFieldError[] = [];\n  const hasStatementsOtherThanSearch = hasNonSearchStatements(root);\n  const isSearchInNestedGroup = isSearchOperatorInsideGroup(root, true);\n\n  // Check if the document ends with 'OR ' to catch incomplete logical operators at the end of the input.\n  const endsWithOR = typeof doc === 'string' && doc.endsWith('OR ');\n  const hasOr = root.logicalOperator === 'OR' || endsWithOR;\n\n  if (\n    // For a group with an explicit or, we need at least two children that are not logical operators\n    // for it to invalidate search operators.\n    // E.g.:\n    // \u203Afoo = bar or\u2039 should still show the search suggestion, since the user may want to search for \"or\".\n    // At this point, the \"or\" is already detected as logical operator (converted to an error node).\n    searchOperators &&\n    ((root.children.filter((child) => !isLogicalOperator(child)).length > 1 &&\n      hasStatementsOtherThanSearch &&\n      hasOr &&\n      searchOperators) ||\n      isSearchInNestedGroup)\n  ) {\n    for (const node of searchOperators) {\n      convertToErrorNode(node);\n      errors.push({\n        range: node.range,\n        message: {\n          type: 'unsupportedSearchWithLogicalOr',\n          details: `<span style=\"color: ${Colors.Syntax.Operators}\">AND</span>`,\n        },\n      });\n    }\n  }\n\n  const isValidSearch =\n    errors.length === 0 &&\n    !(hasOr && hasStatementsOtherThanSearch) &&\n    !isSearchInNestedGroup;\n\n  return { tree: root, errors, isValidSearch };\n}\n\n/** Check if any statements other than search statements are used in a tree. */\nfunction hasNonSearchStatements(root: FilterFieldGroupNode): boolean {\n  return root.children.some((node) => {\n    if (node.type === 'Group') {\n      return hasNonSearchStatements(node);\n    }\n\n    return (\n      isFilterFieldStatementNode(node) &&\n      node.comparisonOperator !== undefined &&\n      node.comparisonOperator.type !== 'SearchOperator'\n    );\n  });\n}\n\n/**\n * Recursively checks if a search operator or a related error node\n * exists inside any non-root group in the filter tree.\n */\nfunction isSearchOperatorInsideGroup(\n  node: FilterFieldGroupNode,\n  isRoot: boolean = true,\n): boolean {\n  for (const child of node.children) {\n    // Recursively check nested groups\n    if (child.type === 'Group') {\n      if (isSearchOperatorInsideGroup(child, false)) {\n        return true;\n      }\n    }\n    // Check for search operator or error in non-root groups\n    if (\n      !isRoot &&\n      isFilterFieldStatementNode(child) &&\n      child.comparisonOperator?.type === 'Error' &&\n      (child.comparisonOperator.value === '* ~' ||\n        child.comparisonOperator.value === '*~')\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n"],
+  "sourcesContent": ["import Colors from '@dynatrace/strato-design-tokens/colors';\n\nimport type { FilterFieldError } from '../../types/filter-field-error.js';\nimport type {\n  FilterFieldGroupNode,\n  FilterFieldNode,\n  FilterFieldSearchOperatorNode,\n} from '../../types/tree-nodes.js';\nimport {\n  isFilterFieldStatementNode,\n  isLogicalOperator,\n} from '../tree-node-guards.js';\nimport { convertToErrorNode } from './lezer-tree-conversion/node-mutations.js';\nimport type { FilterFieldProps } from '../../FilterField.types.js';\nimport type {\n  FilterFieldFlatGroupNode,\n  FilterFieldFlatNode,\n  FilterFieldLogicalOperatorNode,\n} from '../../types/conversion-utils.js';\n\n/**\n * Iterate over the parsed document and convert the lezer tree to an object.\n * @internal\n */\nexport function sortFilterFieldTree(\n  tree: FilterFieldFlatGroupNode | undefined,\n  parserConfig: FilterFieldProps['parserConfig'],\n  doc?: string,\n): {\n  tree: FilterFieldGroupNode | undefined;\n  errors: FilterFieldError[];\n  isValidSearch: boolean;\n} {\n  if (!tree) {\n    return { tree, errors: [], isValidSearch: true };\n  }\n\n  const { tree: _cleanedTree, searchOperators } = groupByLogicalOperators({\n    tree,\n  });\n  let errors: FilterFieldError[] = [];\n\n  let cleanedTree = _cleanedTree;\n  let isValidSearch;\n  // oxlint-disable-next-line typescript/no-deprecated\n  if (parserConfig?.searchConversion === true) {\n    ({\n      tree: cleanedTree,\n      errors,\n      isValidSearch,\n    } = checkValidSearchOperators(cleanedTree, searchOperators, doc));\n  }\n\n  return {\n    tree: cleanedTree,\n    errors,\n    isValidSearch: isValidSearch ?? false,\n  };\n}\n\ntype LogicalOperator = FilterFieldGroupNode['logicalOperator'];\n\n/**\n * Function to group the filter statements depending on the logical operators used.\n */\nfunction groupByLogicalOperators(\n  data: {\n    tree: FilterFieldFlatGroupNode;\n    searchOperators?: FilterFieldSearchOperatorNode[];\n  },\n  group?: FilterFieldGroupNode,\n): {\n  tree: FilterFieldGroupNode;\n  searchOperators: FilterFieldSearchOperatorNode[];\n} {\n  const { tree, searchOperators = [] } = data;\n  const sortedTree: FilterFieldGroupNode = group ?? {\n    type: 'Group',\n    range: tree.range,\n    logicalOperator: 'AND',\n    explicit: tree.explicit,\n    explicitLogicalOperator: false,\n    children: [],\n  };\n\n  let prevLogicalOperator: LogicalOperator | null | undefined;\n  let currentLogicalOperator: LogicalOperator | undefined | null;\n  let nestedTree: FilterFieldGroupNode | undefined;\n\n  // In case of an empty group, return an empty group.\n  if (\n    tree.type === 'Group' &&\n    (tree.children.length === 0 || tree.children[0].type === 'Error')\n  ) {\n    return {\n      tree: {\n        ...tree,\n        logicalOperator: 'AND',\n        explicitLogicalOperator: false,\n        children: tree.children as FilterFieldNode[],\n      },\n      searchOperators,\n    };\n  }\n\n  for (const [index, child] of tree.children.entries()) {\n    // push error nodes to the tree, except logical operators\n    // as they need to be handled separately\n    if (child.type === 'Error' && !isLogicalOperator(child)) {\n      (nestedTree ?? sortedTree).children.push(child);\n    }\n\n    if (\n      child.type === 'Statement' ||\n      (child.type === 'Group' && child.explicit)\n    ) {\n      const prevNode: FilterFieldFlatNode | undefined =\n        tree.children[index - 1];\n\n      if (\n        child.type === 'Statement' &&\n        child.comparisonOperator?.type === 'SearchOperator'\n      ) {\n        // Store search operator to potentially mark all of them as errors in a later step.\n        searchOperators.push(child.comparisonOperator);\n      }\n\n      prevLogicalOperator = currentLogicalOperator;\n      currentLogicalOperator = (\n        isLogicalOperator(prevNode)\n          ? // DEPRECATION: [APPDEV-13773] BREAKING-CHANGE: Exclude logical operator node from public tree type.\n            // Check how to best deal with the logical operator conversion here.\n\n            (prevNode as FilterFieldLogicalOperatorNode).value.toUpperCase()\n          : null\n      ) as FilterFieldGroupNode['logicalOperator'];\n\n      if (prevNode === undefined) {\n        currentLogicalOperator = undefined;\n      }\n\n      // In case the previous logical operator is not equal to the current, we need to group the\n      // previous statement and the current statement and nest them in the tree.\n      // An undefined logical operator indicates that there are no previous statements yet.\n      // E.g.:\n      /*\n        a = 1 OR b = 2 c = 2\n        tree before implicit and: { or: ['a = 1', 'b = 2' ]}\n        -> pop the last statement of the current tree and add it to a new nested\n           tree with the current statement\n        tree after implicit and:  { or: ['a = 1', { and: ['b = 2', 'c = 2]} ]}\n       */\n      const shouldCreateNestedTree =\n        prevLogicalOperator !== undefined &&\n        currentLogicalOperator !== undefined &&\n        currentLogicalOperator !== prevLogicalOperator &&\n        // For an explicit logical operator, a nested tree has already been created when handling the logical operator.\n        prevNode?.type !== 'LogicalOperator';\n\n      if (shouldCreateNestedTree) {\n        // Pop last node of previous tree.\n        const prevNode = sortedTree.children.pop();\n        if (!prevNode) {\n          continue;\n        }\n\n        let nestedChildren: FilterFieldNode;\n        if (child.type === 'Group') {\n          ({ tree: nestedChildren } = groupByLogicalOperators({\n            tree: child,\n            searchOperators,\n          }));\n        } else {\n          nestedChildren = child;\n        }\n\n        // Create new nested tree to push to the previous group.\n        const groupedChildren: FilterFieldNode[] = [prevNode, nestedChildren];\n\n        nestedTree = {\n          type: 'Group',\n          range: {\n            from: prevNode.range.from,\n            to: groupedChildren[groupedChildren.length - 1]?.range.to,\n          },\n          children: groupedChildren,\n          logicalOperator: currentLogicalOperator ?? 'AND',\n          explicitLogicalOperator:\n            currentLogicalOperator !== null &&\n            currentLogicalOperator !== undefined,\n          explicit: false,\n        };\n\n        sortedTree.children.push(nestedTree);\n\n        // Update the nested tree's range to include all of the new group if need be.\n        if (sortedTree.range.to < nestedTree.range.to) {\n          sortedTree.range.to = nestedTree.range.to;\n        }\n      } else {\n        let nestedChildren: FilterFieldNode;\n        if (child.type === 'Group') {\n          ({ tree: nestedChildren } = groupByLogicalOperators(\n            { tree: child, searchOperators },\n            // Pass the created nested tree for implicit groups only to avoid circular structures.\n            // The sorted tree returned at the end of the function is set to the 'group' parameter = nestedTree.\n            // If the child is an explicit group and we would pass the nestedTree, it would be pushed into the\n            // sortedTree of the previous recursion again when returning the current sortedTree.\n            child.explicit ? undefined : nestedTree,\n          ));\n        } else {\n          nestedChildren = child;\n        }\n\n        // If the current node is a group, recursively add the group to the tree.\n        (nestedTree ?? sortedTree).children.push(nestedChildren);\n\n        if (nestedTree) {\n          nestedTree.range.to = child.range.to;\n        }\n        if (!sortedTree.explicit && sortedTree.range.to < child.range.to) {\n          sortedTree.range.to = child.range.to;\n        }\n      }\n    }\n\n    // If the child is an explicit logical operator, depending on the previous\n    // logical operator, we either just push it to the current tree, or create\n    // a nested tree to group the relevant statements and logical operators.\n    // E.g.:\n    /*\n      a = 1 b = 1 OR c = 2\n      Once at the explicit 'OR', group the previous statements (a, b).\n\n      a = 1 OR b = 2 c = 2\n      Once at the implicit 'AND', group the previous statement\n      and the current statement (b, c).\n     */\n    if (isLogicalOperator(child)) {\n      // DEPRECATION: [APPDEV-13773] BREAKING-CHANGE: Exclude logical operator node from public tree type.\n      // Check how to best deal with the logical operator conversion here.\n\n      const convertedChild: FilterFieldLogicalOperatorNode =\n        child as FilterFieldLogicalOperatorNode;\n\n      prevLogicalOperator = currentLogicalOperator;\n      currentLogicalOperator =\n        convertedChild.value.toUpperCase() as FilterFieldGroupNode['logicalOperator'];\n\n      if (\n        prevLogicalOperator !== undefined &&\n        prevLogicalOperator !== currentLogicalOperator\n      ) {\n        if (\n          !nestedTree ||\n          (currentLogicalOperator === 'OR' &&\n            currentLogicalOperator !== sortedTree.logicalOperator &&\n            // Either of the trees has an explicit logical operator. The current logical operator does not match\n            // the operator of the sorted tree. We need to move the existing sorted tree to a nested tree.\n            (sortedTree.explicitLogicalOperator ||\n              nestedTree.explicitLogicalOperator ||\n              // Some deeper nested mixture of implicit and explicit logical and.\n              // With a current logical OR operator, we need to move the existing sorted tree to a nested tree.\n              sortedTree.logicalOperator === nestedTree.logicalOperator)) ||\n          // The current logical operator is an explicit AND with a previous implicit AND and logical OR.\n          // E.g.: b=2 OR c=3 d=4 AND e=5\n          // In this case, we already have a nested tree, but still have to create a new one to group\n          // The implicit and explicit logical AND while not losing the logical OR.\n          (sortedTree.logicalOperator === 'OR' &&\n            currentLogicalOperator === 'AND')\n        ) {\n          // Create a new nested tree.\n          nestedTree = {\n            type: 'Group',\n            logicalOperator: 'AND',\n            range: { from: -1, to: -1 },\n            explicit: false,\n            explicitLogicalOperator:\n              currentLogicalOperator === 'AND' ||\n              (currentLogicalOperator === 'OR' &&\n                sortedTree.explicitLogicalOperator),\n            children: [],\n          };\n\n          // Add all the previous nodes to the new tree until we get to an explicit\n          // logical operator 'OR' operator.\n          // E.g.:\n          /*\n            a = 1 AND b = 1 c = 1 OR d = 2 e = 2\n            Once at the logical 'OR', create a new nested tree to group all the previous statements\n            that are connected with 'AND'.\n            All of them need to be removed from the current tree and pushed to the nested tree.\n\n            a = 1 OR b = 2 AND c = 2\n            Once at the logical 'AND', create a new nested tree, but only include the previous statement (b)\n            and don't move anything before.\n\n            a = 1 b = 2 AND c = 2\n            Once at the logical 'AND', create a new nested tree, but only include the previous statement (b)\n            and don't move anything before to be able to distinguish between explicit and implicit logical and.\n           */\n          let abortGrouping = false;\n          do {\n            const previousNode = sortedTree.children.pop();\n            // Nothing left in the tree -> break;\n            if (!previousNode) {\n              break;\n            }\n\n            nestedTree.children.push(previousNode);\n\n            // If the previous node is a logical 'OR' operator or the sorted tree does not have an explicit logical operator, but\n            // the current logical operator is an explicit 'AND', stop pushing nodes to the nested tree.\n            if (\n              // Switching from logical and to logical or.\n              (sortedTree.explicitLogicalOperator &&\n                sortedTree.logicalOperator === 'OR') ||\n              // Mixture of implicit and explicit logical and.\n              (!sortedTree.explicitLogicalOperator &&\n                currentLogicalOperator === 'AND')\n            ) {\n              abortGrouping = true;\n            }\n          } while (!abortGrouping);\n\n          // Reverse the nested tree to restore the original order of the nodes.\n          nestedTree.children.reverse();\n\n          // Set the start and end index of the nested tree.\n          nestedTree.range.from = nestedTree.children[0]?.range.from;\n          nestedTree.range.to =\n            nestedTree.children[nestedTree.children.length - 1]?.range.to;\n\n          if (\n            currentLogicalOperator === 'AND' &&\n            nestedTree.range.to < child.range.to\n          ) {\n            nestedTree.range.to = child.range.to;\n          }\n\n          if (!nestedTree.children[0]) {\n            nestedTree = undefined;\n          } else {\n            // Push the nested tree to the current tree.\n            sortedTree.children.push(nestedTree);\n            if (currentLogicalOperator === 'OR') {\n              sortedTree.logicalOperator = currentLogicalOperator;\n            }\n          }\n        }\n\n        if (\n          currentLogicalOperator === 'OR' ||\n          (nestedTree?.explicitLogicalOperator === false &&\n            currentLogicalOperator === 'AND')\n        ) {\n          nestedTree = undefined;\n        }\n      } else {\n        (nestedTree ?? sortedTree).explicitLogicalOperator =\n          child.type !== 'Error';\n      }\n\n      // Add the logical operator node to the tree if it is an error node\n      if (child.type === 'Error') {\n        (nestedTree ?? sortedTree).children.push(child);\n      }\n\n      if (!nestedTree) {\n        if (!prevLogicalOperator) {\n          sortedTree.logicalOperator = currentLogicalOperator;\n        }\n\n        if (currentLogicalOperator && child.type !== 'Error') {\n          sortedTree.explicitLogicalOperator = true;\n        }\n        if (sortedTree.range.to < child.range.to) {\n          sortedTree.range.to = child.range.to;\n        }\n      }\n    }\n\n    if (\n      child.type === 'Error' &&\n      (child.value === 'OR' || child.value === 'AND')\n    ) {\n      (nestedTree ?? sortedTree).explicitLogicalOperator = false;\n    }\n  }\n\n  return { tree: sortedTree, searchOperators };\n}\n\n/**\n * Function to check whether search operators are only used in a valid context.\n * A combination of logical or with statements other than search statements is not allowed.\n * Due to the higher precedence of logical and, it is sufficient to check only the root level of the tree\n * and only if the root node's logical operator is a logical or.\n */\nfunction checkValidSearchOperators(\n  root: FilterFieldGroupNode,\n  searchOperators?: FilterFieldSearchOperatorNode[],\n  doc?: string,\n): {\n  tree: FilterFieldGroupNode;\n  errors: FilterFieldError[];\n  isValidSearch: boolean;\n} {\n  const errors: FilterFieldError[] = [];\n  const hasStatementsOtherThanSearch = hasNonSearchStatements(root);\n  const isSearchInNestedGroup = isSearchOperatorInsideGroup(root, true);\n\n  // Check if the document ends with 'OR ' to catch incomplete logical operators at the end of the input.\n  const endsWithOR = typeof doc === 'string' && doc.endsWith('OR ');\n  const hasOr = root.logicalOperator === 'OR' || endsWithOR;\n\n  if (\n    // For a group with an explicit or, we need at least two children that are not logical operators\n    // for it to invalidate search operators.\n    // E.g.:\n    // \u203Afoo = bar or\u2039 should still show the search suggestion, since the user may want to search for \"or\".\n    // At this point, the \"or\" is already detected as logical operator (converted to an error node).\n    searchOperators &&\n    ((root.children.filter((child) => !isLogicalOperator(child)).length > 1 &&\n      hasStatementsOtherThanSearch &&\n      hasOr &&\n      searchOperators) ||\n      isSearchInNestedGroup)\n  ) {\n    for (const node of searchOperators) {\n      convertToErrorNode(node);\n      errors.push({\n        range: node.range,\n        message: {\n          type: 'unsupportedSearchWithLogicalOr',\n          details: `<span style=\"color: ${Colors.Syntax.Operators}\">AND</span>`,\n        },\n      });\n    }\n  }\n\n  const isValidSearch =\n    errors.length === 0 &&\n    !(hasOr && hasStatementsOtherThanSearch) &&\n    !isSearchInNestedGroup;\n\n  return { tree: root, errors, isValidSearch };\n}\n\n/** Check if any statements other than search statements are used in a tree. */\nfunction hasNonSearchStatements(root: FilterFieldGroupNode): boolean {\n  return root.children.some((node) => {\n    if (node.type === 'Group') {\n      return hasNonSearchStatements(node);\n    }\n\n    return (\n      isFilterFieldStatementNode(node) &&\n      node.comparisonOperator !== undefined &&\n      node.comparisonOperator.type !== 'SearchOperator'\n    );\n  });\n}\n\n/**\n * Recursively checks if a search operator or a related error node\n * exists inside any non-root group in the filter tree.\n */\nfunction isSearchOperatorInsideGroup(\n  node: FilterFieldGroupNode,\n  isRoot: boolean = true,\n): boolean {\n  for (const child of node.children) {\n    // Recursively check nested groups\n    if (child.type === 'Group') {\n      if (isSearchOperatorInsideGroup(child, false)) {\n        return true;\n      }\n    }\n    // Check for search operator or error in non-root groups\n    if (\n      !isRoot &&\n      isFilterFieldStatementNode(child) &&\n      child.comparisonOperator?.type === 'Error' &&\n      (child.comparisonOperator.value === '* ~' ||\n        child.comparisonOperator.value === '*~')\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n"],
   "mappings": "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",
   "names": ["prevNode"]
 }

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

@@ -20,6 +20,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;
@@ -50,7 +56,8 @@ function getNestedValue({
   nodeType,
   isFreeText,
   positionOperator,
-  separator
+  separator,
+  preserveWildcards
 }) {
   let value = _value;
   if (value === void 0) {
@@ -89,8 +96,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}"`;
@@ -157,12 +166,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/esm/filters/filter-field/utils/conversion/tree-string-conversion.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/filters/filter-field/utils/conversion/tree-string-conversion.ts"],
-  "sourcesContent": ["import { getNumberParser } from '../../parser/getNumberParser.js';\nimport type {\n  SimpleFilterFieldNode,\n  SimpleFilterFieldTree,\n} from '../../types/conversion-tree-nodes.js';\n/**\n * Conversion util that converts a filter field tree into a string.\n * @param tree - Filter field tree\n * @public\n */\nexport function convertFilterFieldTreeToString(\n  tree?: SimpleFilterFieldTree,\n): string {\n  return _convertFilterFieldTreeToString(tree, '');\n}\n\nfunction getOperatorInfo(\n  operatorValue: string,\n  operatorType: string,\n): {\n  textValue: string;\n  positionOperator: string;\n} {\n  const operatorInfo = {\n    textValue: operatorValue,\n    positionOperator: '',\n  };\n\n  switch (operatorValue) {\n    case 'ends-with':\n    case 'starts-with':\n    case 'contains':\n      operatorInfo.textValue = '=';\n      operatorInfo.positionOperator = operatorValue;\n      break;\n    case 'not-ends-with':\n    case 'not-starts-with':\n    case 'not-contains':\n      operatorInfo.textValue = '!=';\n      operatorInfo.positionOperator = operatorValue.substring(4);\n      break;\n    case 'matches-phrase':\n      operatorInfo.textValue = '~';\n      break;\n    case 'not-matches-phrase':\n      operatorInfo.textValue = '!~';\n      break;\n    case 'search':\n      operatorInfo.textValue = '* ~';\n      break;\n  }\n\n  if (operatorType === 'ExistsOperator') {\n    operatorInfo.textValue = operatorValue ? '= *' : '!= *';\n  }\n\n  if (operatorType === 'SearchOperator') {\n    operatorInfo.textValue = '* ~';\n  }\n\n  return operatorInfo;\n}\n\n/**\n * check if the value has to be wrapped in quotes regardless if it contains a reserved character.\n * this is the case if it is either an empty string or if it is a boolean, number or duration but has\n * the type 'String' (then it has to be escaped, otherwise the type of the value would change)\n */\nfunction hasToBeWrappedInQuotes(\n  value: string,\n  isString: boolean, // whether the nodeType equals 'String'\n  hasPositionOperator: string | undefined,\n): boolean {\n  const numberParser = getNumberParser();\n  const valueAsNumber = numberParser.parse(value);\n  const durationRegex = /^\\d+(ns|ms|s|m|h|d)$/;\n  return (\n    value === '' ||\n    ((value === 'true' || value === 'false') && isString) ||\n    (!isNaN(valueAsNumber) && isString && !hasPositionOperator) ||\n    (durationRegex.test(value) && isString && !hasPositionOperator) ||\n    (value.charAt(0) === '$' && isString)\n  );\n}\n\nfunction getNestedValue({\n  value: _value,\n  textValue,\n  nodeType,\n  isFreeText,\n  positionOperator,\n  separator,\n}: {\n  value: SimpleFilterFieldNode[] | undefined | string | number | boolean;\n  textValue?: string;\n  nodeType:\n    | 'Error'\n    | 'String'\n    | 'Variable'\n    | 'List'\n    | 'Key'\n    | 'JSONPath'\n    | 'Number'\n    | 'BigInt'\n    | 'Boolean'\n    | 'Duration'\n    | 'ComparisonOperator'\n    | 'IPAddress'\n    | 'UID'\n    | 'SmartscapeId'\n    | 'Timestamp'\n    | 'ExistsOperator'\n    | 'SearchOperator'\n    | 'InclusionOperator'\n    | 'Group';\n  isFreeText?: boolean;\n  positionOperator?: string;\n  separator?: string;\n}): string {\n  let value = _value;\n  if (value === undefined) {\n    return '';\n  }\n\n  if (Array.isArray(value)) {\n    let combinedString = '';\n\n    // Recursively convert all included nodes.\n    value.forEach((node, index) => {\n      return (combinedString = _convertFilterFieldTreeToString(\n        node,\n        separator && index !== 0\n          ? `${combinedString}${separator}`\n          : combinedString,\n      ));\n    });\n\n    return combinedString;\n  }\n\n  if (textValue) {\n    // Remove leading '*' or the star in '\"*' if position operator is 'contains' or 'ends-with'\n    if (positionOperator === 'contains' || positionOperator === 'ends-with') {\n      textValue = textValue.replaceAll(/(?<=^\")\\*|^\\*/g, '');\n    }\n\n    // Remove trailing '*' or the star in '*\"' if position operator is 'contains' or 'starts-with'\n    if (positionOperator === 'contains' || positionOperator === 'starts-with') {\n      textValue = textValue.replaceAll(/\\*(?=\"$)|\\*$/g, '');\n    }\n\n    return textValue;\n  }\n\n  value = `${value}`;\n\n  // If the node is an error, we don't escape any characters\n  if (nodeType === 'Error') {\n    if (!isFreeText) {\n      return value;\n    }\n\n    return value.replaceAll(/\\\\/g, '\\\\\\\\');\n  }\n\n  const wrapInQuotes = hasToBeWrappedInQuotes(\n    value,\n    nodeType === 'String',\n    positionOperator,\n  );\n\n  // Escape the escape character ('\\') with an escape character so it is included in the value, not just\n  // escaping the next character\n  value = value.replaceAll(/\\\\/g, '\\\\\\\\');\n\n  // Escape double quotes with an escape character as it cannot be escaped with double quotes\n  value = value.replaceAll(/\"/g, '\\\\\"');\n\n  // Escape '*' symbols with an escape character as it may change the meaning of the syntax tree if escaped with double quotes\n  const positionOperatorInValueRegex = /\\*/g;\n  value = value.replaceAll(positionOperatorInValueRegex, '\\\\*');\n\n  // check if it contains any reserved characters\n  // https://regex101.com/r/iw2j1u/1\n  const reservedCharactersRegex =\n    /(?!^\\$)(?<!\\\\)(?:\\\\\\\\)*[,()!<>=\"$:[\\]~ ]|\\\\$/;\n\n  if (reservedCharactersRegex.test(value) || wrapInQuotes) {\n    return `\"${value}\"`;\n  }\n\n  return value;\n}\n\nfunction _convertFilterFieldTreeToString(\n  tree: SimpleFilterFieldTree | SimpleFilterFieldNode = undefined,\n  convertedString: string = '',\n): string {\n  if (!tree) {\n    return '';\n  }\n\n  switch (tree.type) {\n    case 'Group': {\n      let groupString = '';\n\n      if (tree.explicit) {\n        groupString = '(';\n      }\n\n      const childValues = getNestedValue({\n        value: tree.children,\n        nodeType: tree.type,\n        separator: tree.explicitLogicalOperator\n          ? ` ${tree.logicalOperator}`\n          : '',\n      });\n\n      groupString =\n        groupString +\n        childValues +\n        `${\n          tree.children.length === 1 && tree.explicitLogicalOperator\n            ? ' ' + tree.logicalOperator\n            : ''\n        }`;\n\n      if (tree.explicit) {\n        const lastChild = tree.children[tree.children.length - 1];\n\n        // if the group is not missing a closing bracket add one to the string\n        if (\n          !(\n            lastChild &&\n            lastChild.type === 'Error' &&\n            lastChild.value === '' &&\n            tree.children.length !== 1\n          )\n        ) {\n          groupString += ')';\n        }\n      }\n\n      convertedString = addNodeToString(convertedString, groupString);\n\n      break;\n    }\n    case 'Error':\n      // if it is an empty group error the brackets were already added when handling the group\n      if (tree.value !== '()') {\n        convertedString = addNodeToString(\n          convertedString,\n          getNestedValue({\n            value: tree.value,\n            textValue: tree.textValue,\n            nodeType: tree.type,\n          }),\n        );\n      }\n      break;\n    case 'Statement': {\n      let statement = '';\n      const { key, comparisonOperator, value } = tree;\n\n      if (key && key.type === 'JSONPath') {\n        statement = `${key.value}${comparisonOperator || value ? ' ' : ''}`;\n      } else if (key) {\n        statement = `${getNestedValue({\n          value: key.value,\n          textValue: key.textValue,\n          nodeType: key.type,\n          isFreeText: !(comparisonOperator ?? value),\n        })}${comparisonOperator || value ? ' ' : ''}`;\n      }\n\n      let operatorInfo = { textValue: '', positionOperator: '' };\n\n      if (comparisonOperator) {\n        operatorInfo = getOperatorInfo(\n          comparisonOperator.value as string,\n          comparisonOperator.type,\n        );\n        statement = `${statement}${operatorInfo.textValue}${value ? ' ' : ''}`;\n      }\n\n      if (value) {\n        const val =\n          value.type === 'Duration'\n            ? `${value.value}${value.unit}`\n            : value.value;\n\n        const childValues = getNestedValue({\n          value: val,\n          textValue: value.textValue,\n          nodeType: value.type,\n          positionOperator: operatorInfo.positionOperator,\n          separator: ',',\n        });\n\n        if (\n          value.type === 'List' ||\n          (value.type === 'Error' && Array.isArray(val))\n        ) {\n          statement = `${statement}(${childValues})`;\n        } else if (value.type === 'Error') {\n          statement = statement + childValues;\n        } else {\n          statement =\n            statement +\n            `${\n              operatorInfo.positionOperator === 'contains' ||\n              operatorInfo.positionOperator === 'ends-with'\n                ? '*'\n                : ''\n            }` +\n            childValues +\n            `${\n              operatorInfo.positionOperator === 'contains' ||\n              operatorInfo.positionOperator === 'starts-with'\n                ? '*'\n                : ''\n            }`;\n        }\n      }\n\n      convertedString = addNodeToString(convertedString, statement);\n      break;\n    }\n    case 'JSONPath': {\n      convertedString = addNodeToString(convertedString, tree.value);\n      break;\n    }\n    case 'Duration': {\n      convertedString = addNodeToString(\n        convertedString,\n        `${tree.value}${tree.unit}`,\n      );\n      break;\n    }\n    default:\n      convertedString = addNodeToString(\n        convertedString,\n        getNestedValue({\n          value: tree.value,\n          textValue: tree.textValue,\n          nodeType: tree.type,\n        }),\n      );\n      break;\n  }\n\n  return convertedString;\n}\n\nfunction addNodeToString(sourceString: string, insertionString: string) {\n  if (insertionString) {\n    const firstElement = sourceString === '' || sourceString === '(';\n    return `${sourceString}${firstElement ? '' : ' '}${insertionString}`;\n  }\n  return sourceString;\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { getNumberParser } from '../../parser/getNumberParser.js';\nimport type {\n  SimpleFilterFieldNode,\n  SimpleFilterFieldTree,\n} from '../../types/conversion-tree-nodes.js';\n/**\n * Conversion util that converts a filter field tree into a string.\n * @param tree - Filter field tree\n * @public\n */\nexport function convertFilterFieldTreeToString(\n  tree?: SimpleFilterFieldTree,\n): string {\n  return _convertFilterFieldTreeToString(tree, '');\n}\n\nfunction getOperatorInfo(\n  operatorValue: string,\n  operatorType: string,\n): {\n  textValue: string;\n  positionOperator: string;\n} {\n  const operatorInfo = {\n    textValue: operatorValue,\n    positionOperator: '',\n  };\n\n  switch (operatorValue) {\n    case 'ends-with':\n    case 'starts-with':\n    case 'contains':\n      operatorInfo.textValue = '=';\n      operatorInfo.positionOperator = operatorValue;\n      break;\n    case 'not-ends-with':\n    case 'not-starts-with':\n    case 'not-contains':\n      operatorInfo.textValue = '!=';\n      operatorInfo.positionOperator = operatorValue.substring(4);\n      break;\n    case 'matches-wildcard':\n      operatorInfo.textValue = '=';\n      break;\n    case 'not-matches-wildcard':\n      operatorInfo.textValue = '!=';\n      break;\n    case 'matches-phrase':\n      operatorInfo.textValue = '~';\n      break;\n    case 'not-matches-phrase':\n      operatorInfo.textValue = '!~';\n      break;\n    case 'search':\n      operatorInfo.textValue = '* ~';\n      break;\n  }\n\n  if (operatorType === 'ExistsOperator') {\n    operatorInfo.textValue = operatorValue ? '= *' : '!= *';\n  }\n\n  if (operatorType === 'SearchOperator') {\n    operatorInfo.textValue = '* ~';\n  }\n\n  return operatorInfo;\n}\n\n/**\n * check if the value has to be wrapped in quotes regardless if it contains a reserved character.\n * this is the case if it is either an empty string or if it is a boolean, number or duration but has\n * the type 'String' (then it has to be escaped, otherwise the type of the value would change)\n */\nfunction hasToBeWrappedInQuotes(\n  value: string,\n  isString: boolean, // whether the nodeType equals 'String'\n  hasPositionOperator: string | undefined,\n): boolean {\n  const numberParser = getNumberParser();\n  const valueAsNumber = numberParser.parse(value);\n  const durationRegex = /^\\d+(ns|ms|s|m|h|d)$/;\n  return (\n    value === '' ||\n    ((value === 'true' || value === 'false') && isString) ||\n    (!isNaN(valueAsNumber) && isString && !hasPositionOperator) ||\n    (durationRegex.test(value) && isString && !hasPositionOperator) ||\n    (value.charAt(0) === '$' && isString)\n  );\n}\n\nfunction getNestedValue({\n  value: _value,\n  textValue,\n  nodeType,\n  isFreeText,\n  positionOperator,\n  separator,\n  preserveWildcards,\n}: {\n  value: SimpleFilterFieldNode[] | undefined | string | number | boolean;\n  textValue?: string;\n  nodeType:\n    | 'Error'\n    | 'String'\n    | 'Variable'\n    | 'List'\n    | 'Key'\n    | 'JSONPath'\n    | 'Number'\n    | 'BigInt'\n    | 'Boolean'\n    | 'Duration'\n    | 'ComparisonOperator'\n    | 'IPAddress'\n    | 'UID'\n    | 'SmartscapeId'\n    | 'Timestamp'\n    | 'ExistsOperator'\n    | 'SearchOperator'\n    | 'InclusionOperator'\n    | 'Group';\n  isFreeText?: boolean;\n  positionOperator?: string;\n  separator?: string;\n  preserveWildcards?: boolean;\n}): string {\n  let value = _value;\n  if (value === undefined) {\n    return '';\n  }\n\n  if (Array.isArray(value)) {\n    let combinedString = '';\n\n    // Recursively convert all included nodes.\n    value.forEach((node, index) => {\n      return (combinedString = _convertFilterFieldTreeToString(\n        node,\n        separator && index !== 0\n          ? `${combinedString}${separator}`\n          : combinedString,\n      ));\n    });\n\n    return combinedString;\n  }\n\n  if (textValue) {\n    // Remove leading '*' or the star in '\"*' if position operator is 'contains' or 'ends-with'\n    if (positionOperator === 'contains' || positionOperator === 'ends-with') {\n      textValue = textValue.replaceAll(/(?<=^\")\\*|^\\*/g, '');\n    }\n\n    // Remove trailing '*' or the star in '*\"' if position operator is 'contains' or 'starts-with'\n    if (positionOperator === 'contains' || positionOperator === 'starts-with') {\n      textValue = textValue.replaceAll(/\\*(?=\"$)|\\*$/g, '');\n    }\n\n    return textValue;\n  }\n\n  value = `${value}`;\n\n  // If the node is an error, we don't escape any characters\n  if (nodeType === 'Error') {\n    if (!isFreeText) {\n      return value;\n    }\n\n    return value.replaceAll(/\\\\/g, '\\\\\\\\');\n  }\n\n  const wrapInQuotes = hasToBeWrappedInQuotes(\n    value,\n    nodeType === 'String',\n    positionOperator,\n  );\n\n  // Escape the escape character ('\\') with an escape character so it is included in the value, not just\n  // escaping the next character\n  value = value.replaceAll(/\\\\/g, '\\\\\\\\');\n\n  // Escape double quotes with an escape character as it cannot be escaped with double quotes\n  value = value.replaceAll(/\"/g, '\\\\\"');\n\n  // Escape '*' symbols with an escape character as it may change the meaning of the syntax tree if escaped with double quotes\n  // Unless preserveWildcards is true, in which case * is a wildcard and should not be escaped\n  if (!preserveWildcards) {\n    const positionOperatorInValueRegex = /\\*/g;\n    value = value.replaceAll(positionOperatorInValueRegex, '\\\\*');\n  }\n\n  // check if it contains any reserved characters\n  // https://regex101.com/r/iw2j1u/1\n  const reservedCharactersRegex =\n    /(?!^\\$)(?<!\\\\)(?:\\\\\\\\)*[,()!<>=\"$:[\\]~ ]|\\\\$/;\n\n  if (reservedCharactersRegex.test(value) || wrapInQuotes) {\n    return `\"${value}\"`;\n  }\n\n  return value;\n}\n\nfunction _convertFilterFieldTreeToString(\n  tree: SimpleFilterFieldTree | SimpleFilterFieldNode = undefined,\n  convertedString: string = '',\n): string {\n  if (!tree) {\n    return '';\n  }\n\n  switch (tree.type) {\n    case 'Group': {\n      let groupString = '';\n\n      if (tree.explicit) {\n        groupString = '(';\n      }\n\n      const childValues = getNestedValue({\n        value: tree.children,\n        nodeType: tree.type,\n        separator: tree.explicitLogicalOperator\n          ? ` ${tree.logicalOperator}`\n          : '',\n      });\n\n      groupString =\n        groupString +\n        childValues +\n        `${\n          tree.children.length === 1 && tree.explicitLogicalOperator\n            ? ' ' + tree.logicalOperator\n            : ''\n        }`;\n\n      if (tree.explicit) {\n        const lastChild = tree.children[tree.children.length - 1];\n\n        // if the group is not missing a closing bracket add one to the string\n        if (\n          !(\n            lastChild &&\n            lastChild.type === 'Error' &&\n            lastChild.value === '' &&\n            tree.children.length !== 1\n          )\n        ) {\n          groupString += ')';\n        }\n      }\n\n      convertedString = addNodeToString(convertedString, groupString);\n\n      break;\n    }\n    case 'Error':\n      // if it is an empty group error the brackets were already added when handling the group\n      if (tree.value !== '()') {\n        convertedString = addNodeToString(\n          convertedString,\n          getNestedValue({\n            value: tree.value,\n            textValue: tree.textValue,\n            nodeType: tree.type,\n          }),\n        );\n      }\n      break;\n    case 'Statement': {\n      let statement = '';\n      const { key, comparisonOperator, value } = tree;\n\n      if (key && key.type === 'JSONPath') {\n        statement = `${key.value}${comparisonOperator || value ? ' ' : ''}`;\n      } else if (key) {\n        statement = `${getNestedValue({\n          value: key.value,\n          textValue: key.textValue,\n          nodeType: key.type,\n          isFreeText: !(comparisonOperator ?? value),\n        })}${comparisonOperator || value ? ' ' : ''}`;\n      }\n\n      let operatorInfo = { textValue: '', positionOperator: '' };\n\n      if (comparisonOperator) {\n        operatorInfo = getOperatorInfo(\n          comparisonOperator.value as string,\n          comparisonOperator.type,\n        );\n        statement = `${statement}${operatorInfo.textValue}${value ? ' ' : ''}`;\n      }\n\n      if (value) {\n        const val =\n          value.type === 'Duration'\n            ? `${value.value}${value.unit}`\n            : value.value;\n\n        // For matches-wildcard / not-matches-wildcard, preserve * in values without textValue\n        const shouldPreserveWildcards =\n          comparisonOperator?.value === 'matches-wildcard' ||\n          comparisonOperator?.value === 'not-matches-wildcard';\n\n        const childValues = getNestedValue({\n          value: val,\n          textValue: value.textValue,\n          nodeType: value.type,\n          positionOperator: operatorInfo.positionOperator,\n          separator: ',',\n          preserveWildcards: shouldPreserveWildcards,\n        });\n\n        if (\n          value.type === 'List' ||\n          (value.type === 'Error' && Array.isArray(val))\n        ) {\n          statement = `${statement}(${childValues})`;\n        } else if (value.type === 'Error') {\n          statement = statement + childValues;\n        } else {\n          statement =\n            statement +\n            `${\n              operatorInfo.positionOperator === 'contains' ||\n              operatorInfo.positionOperator === 'ends-with'\n                ? '*'\n                : ''\n            }` +\n            childValues +\n            `${\n              operatorInfo.positionOperator === 'contains' ||\n              operatorInfo.positionOperator === 'starts-with'\n                ? '*'\n                : ''\n            }`;\n        }\n      }\n\n      convertedString = addNodeToString(convertedString, statement);\n      break;\n    }\n    case 'JSONPath': {\n      convertedString = addNodeToString(convertedString, tree.value);\n      break;\n    }\n    case 'Duration': {\n      convertedString = addNodeToString(\n        convertedString,\n        `${tree.value}${tree.unit}`,\n      );\n      break;\n    }\n    default:\n      convertedString = addNodeToString(\n        convertedString,\n        getNestedValue({\n          value: tree.value,\n          textValue: tree.textValue,\n          nodeType: tree.type,\n        }),\n      );\n      break;\n  }\n\n  return convertedString;\n}\n\nfunction addNodeToString(sourceString: string, insertionString: string) {\n  if (insertionString) {\n    const firstElement = sourceString === '' || sourceString === '(';\n    return `${sourceString}${firstElement ? '' : ' '}${insertionString}`;\n  }\n  return sourceString;\n}\n"],
+  "mappings": "AAAA,SAAS,uBAAuB;AAUzB,SAAS,+BACd,MACQ;AACR,SAAO,gCAAgC,MAAM,EAAE;AACjD;AAEA,SAAS,gBACP,eACA,cAIA;AACA,QAAM,eAAe;AAAA,IACnB,WAAW;AAAA,IACX,kBAAkB;AAAA,EACpB;AAEA,UAAQ,eAAe;AAAA,IACrB,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,mBAAa,YAAY;AACzB,mBAAa,mBAAmB;AAChC;AAAA,IACF,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,mBAAa,YAAY;AACzB,mBAAa,mBAAmB,cAAc,UAAU,CAAC;AACzD;AAAA,IACF,KAAK;AACH,mBAAa,YAAY;AACzB;AAAA,IACF,KAAK;AACH,mBAAa,YAAY;AACzB;AAAA,IACF,KAAK;AACH,mBAAa,YAAY;AACzB;AAAA,IACF,KAAK;AACH,mBAAa,YAAY;AACzB;AAAA,IACF,KAAK;AACH,mBAAa,YAAY;AACzB;AAAA,EACJ;AAEA,MAAI,iBAAiB,kBAAkB;AACrC,iBAAa,YAAY,gBAAgB,QAAQ;AAAA,EACnD;AAEA,MAAI,iBAAiB,kBAAkB;AACrC,iBAAa,YAAY;AAAA,EAC3B;AAEA,SAAO;AACT;AAOA,SAAS,uBACP,OACA,UACA,qBACS;AACT,QAAM,eAAe,gBAAgB;AACrC,QAAM,gBAAgB,aAAa,MAAM,KAAK;AAC9C,QAAM,gBAAgB;AACtB,SACE,UAAU,OACR,UAAU,UAAU,UAAU,YAAY,YAC3C,CAAC,MAAM,aAAa,KAAK,YAAY,CAAC,uBACtC,cAAc,KAAK,KAAK,KAAK,YAAY,CAAC,uBAC1C,MAAM,OAAO,CAAC,MAAM,OAAO;AAEhC;AAEA,SAAS,eAAe;AAAA,EACtB,OAAO;AAAA,EACP;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GA2BW;AACT,MAAI,QAAQ;AACZ,MAAI,UAAU,QAAW;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,QAAI,iBAAiB;AAGrB,UAAM,QAAQ,CAAC,MAAM,UAAU;AAC7B,aAAQ,iBAAiB;AAAA,QACvB;AAAA,QACA,aAAa,UAAU,IACnB,GAAG,cAAc,GAAG,SAAS,KAC7B;AAAA,MACN;AAAA,IACF,CAAC;AAED,WAAO;AAAA,EACT;AAEA,MAAI,WAAW;AAEb,QAAI,qBAAqB,cAAc,qBAAqB,aAAa;AACvE,kBAAY,UAAU,WAAW,kBAAkB,EAAE;AAAA,IACvD;AAGA,QAAI,qBAAqB,cAAc,qBAAqB,eAAe;AACzE,kBAAY,UAAU,WAAW,iBAAiB,EAAE;AAAA,IACtD;AAEA,WAAO;AAAA,EACT;AAEA,UAAQ,GAAG,KAAK;AAGhB,MAAI,aAAa,SAAS;AACxB,QAAI,CAAC,YAAY;AACf,aAAO;AAAA,IACT;AAEA,WAAO,MAAM,WAAW,OAAO,MAAM;AAAA,EACvC;AAEA,QAAM,eAAe;AAAA,IACnB;AAAA,IACA,aAAa;AAAA,IACb;AAAA,EACF;AAIA,UAAQ,MAAM,WAAW,OAAO,MAAM;AAGtC,UAAQ,MAAM,WAAW,MAAM,KAAK;AAIpC,MAAI,CAAC,mBAAmB;AACtB,UAAM,+BAA+B;AACrC,YAAQ,MAAM,WAAW,8BAA8B,KAAK;AAAA,EAC9D;AAIA,QAAM,0BACJ;AAEF,MAAI,wBAAwB,KAAK,KAAK,KAAK,cAAc;AACvD,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO;AACT;AAEA,SAAS,gCACP,OAAsD,QACtD,kBAA0B,IAClB;AACR,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AAEA,UAAQ,KAAK,MAAM;AAAA,IACjB,KAAK,SAAS;AACZ,UAAI,cAAc;AAElB,UAAI,KAAK,UAAU;AACjB,sBAAc;AAAA,MAChB;AAEA,YAAM,cAAc,eAAe;AAAA,QACjC,OAAO,KAAK;AAAA,QACZ,UAAU,KAAK;AAAA,QACf,WAAW,KAAK,0BACZ,IAAI,KAAK,eAAe,KACxB;AAAA,MACN,CAAC;AAED,oBACE,cACA,cACA,GACE,KAAK,SAAS,WAAW,KAAK,KAAK,0BAC/B,MAAM,KAAK,kBACX,EACN;AAEF,UAAI,KAAK,UAAU;AACjB,cAAM,YAAY,KAAK,SAAS,KAAK,SAAS,SAAS,CAAC;AAGxD,YACE,EACE,aACA,UAAU,SAAS,WACnB,UAAU,UAAU,MACpB,KAAK,SAAS,WAAW,IAE3B;AACA,yBAAe;AAAA,QACjB;AAAA,MACF;AAEA,wBAAkB,gBAAgB,iBAAiB,WAAW;AAE9D;AAAA,IACF;AAAA,IACA,KAAK;AAEH,UAAI,KAAK,UAAU,MAAM;AACvB,0BAAkB;AAAA,UAChB;AAAA,UACA,eAAe;AAAA,YACb,OAAO,KAAK;AAAA,YACZ,WAAW,KAAK;AAAA,YAChB,UAAU,KAAK;AAAA,UACjB,CAAC;AAAA,QACH;AAAA,MACF;AACA;AAAA,IACF,KAAK,aAAa;AAChB,UAAI,YAAY;AAChB,YAAM,EAAE,KAAK,oBAAoB,MAAM,IAAI;AAE3C,UAAI,OAAO,IAAI,SAAS,YAAY;AAClC,oBAAY,GAAG,IAAI,KAAK,GAAG,sBAAsB,QAAQ,MAAM,EAAE;AAAA,MACnE,WAAW,KAAK;AACd,oBAAY,GAAG,eAAe;AAAA,UAC5B,OAAO,IAAI;AAAA,UACX,WAAW,IAAI;AAAA,UACf,UAAU,IAAI;AAAA,UACd,YAAY,EAAE,sBAAsB;AAAA,QACtC,CAAC,CAAC,GAAG,sBAAsB,QAAQ,MAAM,EAAE;AAAA,MAC7C;AAEA,UAAI,eAAe,EAAE,WAAW,IAAI,kBAAkB,GAAG;AAEzD,UAAI,oBAAoB;AACtB,uBAAe;AAAA,UACb,mBAAmB;AAAA,UACnB,mBAAmB;AAAA,QACrB;AACA,oBAAY,GAAG,SAAS,GAAG,aAAa,SAAS,GAAG,QAAQ,MAAM,EAAE;AAAA,MACtE;AAEA,UAAI,OAAO;AACT,cAAM,MACJ,MAAM,SAAS,aACX,GAAG,MAAM,KAAK,GAAG,MAAM,IAAI,KAC3B,MAAM;AAGZ,cAAM,0BACJ,oBAAoB,UAAU,sBAC9B,oBAAoB,UAAU;AAEhC,cAAM,cAAc,eAAe;AAAA,UACjC,OAAO;AAAA,UACP,WAAW,MAAM;AAAA,UACjB,UAAU,MAAM;AAAA,UAChB,kBAAkB,aAAa;AAAA,UAC/B,WAAW;AAAA,UACX,mBAAmB;AAAA,QACrB,CAAC;AAED,YACE,MAAM,SAAS,UACd,MAAM,SAAS,WAAW,MAAM,QAAQ,GAAG,GAC5C;AACA,sBAAY,GAAG,SAAS,IAAI,WAAW;AAAA,QACzC,WAAW,MAAM,SAAS,SAAS;AACjC,sBAAY,YAAY;AAAA,QAC1B,OAAO;AACL,sBACE,YACA,GACE,aAAa,qBAAqB,cAClC,aAAa,qBAAqB,cAC9B,MACA,EACN,KACA,cACA,GACE,aAAa,qBAAqB,cAClC,aAAa,qBAAqB,gBAC9B,MACA,EACN;AAAA,QACJ;AAAA,MACF;AAEA,wBAAkB,gBAAgB,iBAAiB,SAAS;AAC5D;AAAA,IACF;AAAA,IACA,KAAK,YAAY;AACf,wBAAkB,gBAAgB,iBAAiB,KAAK,KAAK;AAC7D;AAAA,IACF;AAAA,IACA,KAAK,YAAY;AACf,wBAAkB;AAAA,QAChB;AAAA,QACA,GAAG,KAAK,KAAK,GAAG,KAAK,IAAI;AAAA,MAC3B;AACA;AAAA,IACF;AAAA,IACA;AACE,wBAAkB;AAAA,QAChB;AAAA,QACA,eAAe;AAAA,UACb,OAAO,KAAK;AAAA,UACZ,WAAW,KAAK;AAAA,UAChB,UAAU,KAAK;AAAA,QACjB,CAAC;AAAA,MACH;AACA;AAAA,EACJ;AAEA,SAAO;AACT;AAEA,SAAS,gBAAgB,cAAsB,iBAAyB;AACtE,MAAI,iBAAiB;AACnB,UAAM,eAAe,iBAAiB,MAAM,iBAAiB;AAC7D,WAAO,GAAG,YAAY,GAAG,eAAe,KAAK,GAAG,GAAG,eAAe;AAAA,EACpE;AACA,SAAO;AACT;",
   "names": []
 }

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

@@ -10,9 +10,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/esm/filters/filter-field/utils/escape-suggestion.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/filters/filter-field/utils/escape-suggestion.ts"],
-  "sourcesContent": ["// Regex that matches all words which are properly defined variable names\n// (Case in-sensitive, alphanumeric, optionally split by \"_\", or \".\")\nconst IS_VARIABLE_REGEX = /^\\$[a-zA-Z]+[a-zA-Z0-9]*(?:[_.][a-zA-Z0-9]+)*$/g;\n\nconst BASE_RESERVED_CHARACTERS = ' *\\\\()!<>=\"~';\nexport const RESERVED_CHARACTERS = `${BASE_RESERVED_CHARACTERS}\\\\\\\\`;\n\n/**\n * Regex that matches all characters that need to be escaped, but are not.\n * The backslash needs to be excluded in the BASE_RESERVED_CHARACTERS to not get\n * overlapping matches.\n * E.g. foo = \\*\n * Should not match, but would if we included the backslash in the first character set.\n * Regex + Javascript string escaping = Fun with backslashes.\n * https://regex101.com/r/gPeWnE\n * @internal\n */\nexport const NEEDS_ESCAPING_REGEX = `(?<!\\\\\\\\)(?:\\\\\\\\\\\\\\\\)*[${BASE_RESERVED_CHARACTERS}]|(\\\\\\\\$)`;\n\n/**\n * Regex that matches all escaped characters, including the escape character and escaped character.\n * https://regex101.com/r/LNo0qJ/1\n * @internal\n */\nexport const ESCAPED_CHARACTERS_REGEX = /\\\\(?:.)/g;\n\n/**\n * Escapes a suggestion value by wrapping it in double quotes if it contains\n * reserved characters that need escaping.\n *\n * @param value - The suggestion value to escape.\n * @returns The escaped suggestion value, wrapped in double quotes if necessary.\n * @public\n */\nexport function escapeSuggestion(value: string): string {\n  // A standalone asterisk (position operator) and exists operators are the\n  // only suggestions that should not be escaped automatically.\n  if (value === '*' || value === '= *' || value === '!= *') {\n    return value;\n  }\n\n  // Properly defined variables should not get escaped\n  if (value.startsWith('$') && new RegExp(IS_VARIABLE_REGEX).exec(value)) {\n    return value;\n  }\n\n  // Regex to check if the string is already escaped (also checking for escaped double quotes inside the string)\n  // https://regex101.com/r/8SXgGW/1\n  const isSuggestionEscaped = new RegExp(/^\"(?:[^\"\\\\]|\\\\\")*\"$/).exec(value);\n\n  if (isSuggestionEscaped) {\n    return value;\n  }\n\n  const matches = new RegExp(NEEDS_ESCAPING_REGEX, 'g').exec(value);\n\n  // If the regex matches, there is at least one character in the applied suggestion that\n  // needs to be escaped, but is not. In this case, we wrap the whole suggestion in\n  // doublequotes. Doublequotes occurring in the applied value that are not yet escaped are\n  // escaped with a backslash to not close the string. A single trailing backslash (\\) is also\n  // escaped to avoid ending the string with an unescaped backslash. It would not be necessary to\n  // wrap 'te\\\"st' in doublequotes, since the included doublequote is already escaped by a\n  // backslash. To not overcomplicate the logic, we still wrap the whole value.\n  if (matches) {\n    return `\"${value\n      .replace(/(?<!\\\\)(?:\\\\\\\\)*\"/g, '\\\\\"')\n      .replace(/(?<!\\\\)(?:\\\\\\\\)*\\*/g, '\\\\*')\n      .replace(/(?<!\\\\)(?:\\\\\\\\)*\\\\$/g, '$&\\\\')}\"`;\n  }\n\n  return value;\n}\n"],
-  "mappings": "AAEA,MAAM,oBAAoB;AAE1B,MAAM,2BAA2B;AAC1B,MAAM,sBAAsB,GAAG,wBAAwB;AAYvD,MAAM,uBAAuB,0BAA0B,wBAAwB;AAO/E,MAAM,2BAA2B;AAUjC,SAAS,iBAAiB,OAAuB;AAGtD,MAAI,UAAU,OAAO,UAAU,SAAS,UAAU,QAAQ;AACxD,WAAO;AAAA,EACT;AAGA,MAAI,MAAM,WAAW,GAAG,KAAK,IAAI,OAAO,iBAAiB,EAAE,KAAK,KAAK,GAAG;AACtE,WAAO;AAAA,EACT;AAIA,QAAM,sBAAsB,IAAI,OAAO,qBAAqB,EAAE,KAAK,KAAK;AAExE,MAAI,qBAAqB;AACvB,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,IAAI,OAAO,sBAAsB,GAAG,EAAE,KAAK,KAAK;AAShE,MAAI,SAAS;AACX,WAAO,IAAI,MACR,QAAQ,sBAAsB,KAAK,EACnC,QAAQ,uBAAuB,KAAK,EACpC,QAAQ,wBAAwB,MAAM,CAAC;AAAA,EAC5C;AAEA,SAAO;AACT;",
+  "sourcesContent": ["// Regex that matches all words which are properly defined variable names\n// (Case in-sensitive, alphanumeric, optionally split by \"_\", or \".\")\nconst IS_VARIABLE_REGEX = /^\\$[a-zA-Z]+[a-zA-Z0-9]*(?:[_.][a-zA-Z0-9]+)*$/g;\n\nconst BASE_RESERVED_CHARACTERS = ' *\\\\()!<>=\"~';\nexport const RESERVED_CHARACTERS = `${BASE_RESERVED_CHARACTERS}\\\\\\\\`;\n\n/**\n * Regex that matches all characters that need to be escaped, but are not.\n * The backslash needs to be excluded in the BASE_RESERVED_CHARACTERS to not get\n * overlapping matches.\n * E.g. foo = \\*\n * Should not match, but would if we included the backslash in the first character set.\n * Regex + Javascript string escaping = Fun with backslashes.\n * https://regex101.com/r/gPeWnE\n * @internal\n */\nexport const NEEDS_ESCAPING_REGEX = `(?<!\\\\\\\\)(?:\\\\\\\\\\\\\\\\)*[${BASE_RESERVED_CHARACTERS}]|(\\\\\\\\$)`;\n\n/**\n * Regex that matches all escaped characters, including the escape character and escaped character.\n * https://regex101.com/r/LNo0qJ/1\n * @internal\n */\nexport const ESCAPED_CHARACTERS_REGEX = /\\\\(?:.)/g;\n\n/**\n * Escapes a suggestion value by wrapping it in double quotes if it contains\n * reserved characters that need escaping.\n *\n * @param value - The suggestion value to escape.\n * @returns The escaped suggestion value, wrapped in double quotes if necessary.\n * @public\n */\nexport function escapeSuggestion(value: string): string {\n  // A standalone asterisk (position operator) and exists operators are the\n  // only suggestions that should not be escaped automatically.\n  if (value === '*' || value === '= *' || value === '!= *') {\n    return value;\n  }\n\n  // Properly defined variables should not get escaped\n  if (value.startsWith('$') && new RegExp(IS_VARIABLE_REGEX).exec(value)) {\n    return value;\n  }\n\n  // Regex to check if the string is already escaped (also checking for escaped double quotes inside the string)\n  // https://regex101.com/r/8SXgGW/1\n  const isSuggestionEscaped = new RegExp(/^\"(?:[^\"\\\\]|\\\\.)*(?:\"|\\\\\")$/).exec(\n    value,\n  );\n\n  if (isSuggestionEscaped) {\n    // Already quoted \u2014 still escape any unescaped wildcards inside the string.\n    const inner = value.slice(1, -1);\n    const escapedInner = inner.replace(/(?<!\\\\)(?:\\\\\\\\)*\\*/g, '\\\\*');\n    return `\"${escapedInner}\"`;\n  }\n\n  const matches = new RegExp(NEEDS_ESCAPING_REGEX, 'g').exec(value);\n\n  // If the regex matches, there is at least one character in the applied suggestion that\n  // needs to be escaped, but is not. In this case, we wrap the whole suggestion in\n  // doublequotes. Doublequotes occurring in the applied value that are not yet escaped are\n  // escaped with a backslash to not close the string. A single trailing backslash (\\) is also\n  // escaped to avoid ending the string with an unescaped backslash. It would not be necessary to\n  // wrap 'te\\\"st' in doublequotes, since the included doublequote is already escaped by a\n  // backslash. To not overcomplicate the logic, we still wrap the whole value.\n  if (matches) {\n    return `\"${value\n      .replace(/(?<!\\\\)(?:\\\\\\\\)*\"/g, '\\\\\"')\n      .replace(/(?<!\\\\)(?:\\\\\\\\)*\\*/g, '\\\\*')\n      .replace(/(?<!\\\\)(?:\\\\\\\\)*\\\\$/g, '$&\\\\')}\"`;\n  }\n\n  return value;\n}\n"],
+  "mappings": "AAEA,MAAM,oBAAoB;AAE1B,MAAM,2BAA2B;AAC1B,MAAM,sBAAsB,GAAG,wBAAwB;AAYvD,MAAM,uBAAuB,0BAA0B,wBAAwB;AAO/E,MAAM,2BAA2B;AAUjC,SAAS,iBAAiB,OAAuB;AAGtD,MAAI,UAAU,OAAO,UAAU,SAAS,UAAU,QAAQ;AACxD,WAAO;AAAA,EACT;AAGA,MAAI,MAAM,WAAW,GAAG,KAAK,IAAI,OAAO,iBAAiB,EAAE,KAAK,KAAK,GAAG;AACtE,WAAO;AAAA,EACT;AAIA,QAAM,sBAAsB,IAAI,OAAO,6BAA6B,EAAE;AAAA,IACpE;AAAA,EACF;AAEA,MAAI,qBAAqB;AAEvB,UAAM,QAAQ,MAAM,MAAM,GAAG,EAAE;AAC/B,UAAM,eAAe,MAAM,QAAQ,uBAAuB,KAAK;AAC/D,WAAO,IAAI,YAAY;AAAA,EACzB;AAEA,QAAM,UAAU,IAAI,OAAO,sBAAsB,GAAG,EAAE,KAAK,KAAK;AAShE,MAAI,SAAS;AACX,WAAO,IAAI,MACR,QAAQ,sBAAsB,KAAK,EACnC,QAAQ,uBAAuB,KAAK,EACpC,QAAQ,wBAAwB,MAAM,CAAC;AAAA,EAC5C;AAEA,SAAO;AACT;",
   "names": []
 }

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/filters/filter-field/utils/generate-errors-or-diagnostics.ts"],
-  "sourcesContent": ["import type { Diagnostic } from '@codemirror/lint';\nimport type { RangeSet } from '@codemirror/state';\nimport { RangeSetBuilder } from '@codemirror/state';\nimport type { Decoration, EditorView } from '@codemirror/view';\n\nimport { filterFieldErrorWrapperClass } from '../../../core/styles/diagnostic-tooltip.sty.js';\nimport { renderDiagnosticMessage } from '../../../core/utils/diagnostic-tooltip/render-diagnostic-message.js';\nimport { errorMark } from '../decorations/decoration-marks.js';\nimport {\n  pastingMode,\n  usedErrors,\n  type PastingInfo,\n} from '../editor-state-configs/editor-config.js';\nimport type { FilterFieldErrorMessages } from '../types/filter-field-error.js';\n\n/** @internal */\nexport function generateErrorsOrDiagnostics(\n  view: EditorView,\n): RangeSet<Decoration>;\n/** @internal */\nexport function generateErrorsOrDiagnostics(\n  view: EditorView,\n  messages?: FilterFieldErrorMessages,\n): Diagnostic[];\n/** @internal */\nexport function generateErrorsOrDiagnostics(\n  view: EditorView,\n  messages?: FilterFieldErrorMessages,\n): RangeSet<Decoration> | Diagnostic[] {\n  const builder = new RangeSetBuilder<Decoration>();\n  const diagnostics: Diagnostic[] = [];\n  const errorsStateField = view.state.field(usedErrors, false);\n  const pastingStateField = view?.state.field(pastingMode, false);\n\n  if (!errorsStateField || view.visibleRanges.length === 0) {\n    if (messages !== undefined) {\n      builder.finish();\n      return diagnostics;\n    }\n\n    return builder.finish();\n  }\n\n  for (const error of errorsStateField.errors) {\n    const {\n      range: { from, to },\n      decoration,\n      message: errorMessage,\n    } = error;\n    let message;\n    let messageDetails: string | string[] | undefined;\n\n    if (typeof errorMessage === 'string') {\n      message = errorMessage;\n    } else {\n      message = errorMessage.type;\n      messageDetails = errorMessage.details;\n    }\n\n    if (from <= view.visibleRanges[0].to && to <= view.visibleRanges[0].to) {\n      const showError = !isErrorInPastingRange(from, to, pastingStateField);\n\n      if (showError) {\n        builder.add(from, to, decoration ?? errorMark);\n      }\n\n      if (messages !== undefined) {\n        let errorMessage = message;\n        const errorType = messages[message as keyof FilterFieldErrorMessages];\n        if (errorType) {\n          if (typeof errorType === 'function') {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- The correct details type is always paired with the matching error type at runtime.\n            errorMessage = (errorType as (...args: any[]) => string)(\n              messageDetails,\n            );\n          } else {\n            errorMessage = errorType;\n          }\n        }\n\n        if (showError) {\n          diagnostics.push({\n            from,\n            to,\n            severity: 'error',\n            message: '',\n            // FilterField messages embed trusted, internally generated markup (syntax-colored\n            // operators), so they are rendered as HTML rather than escaped text.\n            renderMessage: renderDiagnosticMessage(\n              'error',\n              errorMessage,\n              filterFieldErrorWrapperClass,\n              { dangerouslyRenderHtml: true },\n            ),\n          });\n        }\n      }\n    }\n  }\n\n  if (messages !== undefined) {\n    builder.finish();\n    return diagnostics;\n  }\n\n  return builder.finish();\n}\n\nfunction isErrorInPastingRange(\n  errorFrom: number,\n  errorTo: number,\n  pastingStateField: PastingInfo | undefined,\n) {\n  if (!pastingStateField?.range || !pastingStateField.pastingInProgress) {\n    return false;\n  }\n\n  const pastingRangeFrom = pastingStateField.range.from;\n  const pastingRangeTo = pastingStateField.range.to;\n\n  return (\n    // Check if error starts inside the pasting range\n    // Check if error surrounds the pasting range\n    (errorFrom >= pastingRangeFrom && errorFrom <= pastingRangeTo) ||\n    // Check if error starts inside the pasting range\n    (errorTo >= pastingRangeFrom && errorTo <= pastingRangeFrom) ||\n    (errorFrom <= pastingRangeFrom && errorTo >= pastingRangeTo)\n  );\n}\n"],
+  "sourcesContent": ["import type { Diagnostic } from '@codemirror/lint';\nimport type { RangeSet } from '@codemirror/state';\nimport { RangeSetBuilder } from '@codemirror/state';\nimport type { Decoration, EditorView } from '@codemirror/view';\n\nimport { filterFieldErrorWrapperClass } from '../../../core/styles/diagnostic-tooltip.sty.js';\nimport { renderDiagnosticMessage } from '../../../core/utils/diagnostic-tooltip/render-diagnostic-message.js';\nimport { errorMark } from '../decorations/decoration-marks.js';\nimport {\n  pastingMode,\n  usedErrors,\n  type PastingInfo,\n} from '../editor-state-configs/editor-config.js';\nimport type { FilterFieldErrorMessages } from '../types/filter-field-error.js';\n\n/** @internal */\nexport function generateErrorsOrDiagnostics(\n  view: EditorView,\n): RangeSet<Decoration>;\n/** @internal */\nexport function generateErrorsOrDiagnostics(\n  view: EditorView,\n  messages?: FilterFieldErrorMessages,\n): Diagnostic[];\n/** @internal */\nexport function generateErrorsOrDiagnostics(\n  view: EditorView,\n  messages?: FilterFieldErrorMessages,\n): RangeSet<Decoration> | Diagnostic[] {\n  const builder = new RangeSetBuilder<Decoration>();\n  const diagnostics: Diagnostic[] = [];\n  const errorsStateField = view.state.field(usedErrors, false);\n  const pastingStateField = view?.state.field(pastingMode, false);\n\n  if (!errorsStateField || view.visibleRanges.length === 0) {\n    if (messages !== undefined) {\n      builder.finish();\n      return diagnostics;\n    }\n\n    return builder.finish();\n  }\n\n  for (const error of errorsStateField.errors) {\n    const {\n      range: { from, to },\n      decoration,\n      message: errorMessage,\n    } = error;\n    let message;\n    let messageDetails: string | string[] | undefined;\n\n    if (typeof errorMessage === 'string') {\n      message = errorMessage;\n    } else {\n      message = errorMessage.type;\n      messageDetails = errorMessage.details;\n    }\n\n    if (from <= view.visibleRanges[0].to && to <= view.visibleRanges[0].to) {\n      const showError = !isErrorInPastingRange(from, to, pastingStateField);\n\n      if (showError) {\n        builder.add(from, to, decoration ?? errorMark);\n      }\n\n      if (messages !== undefined) {\n        let errorMessage = message;\n        const errorType = messages[message as keyof FilterFieldErrorMessages];\n        if (errorType) {\n          if (typeof errorType === 'function') {\n            // oxlint-disable-next-line typescript/no-explicit-any -- The correct details type is always paired with the matching error type at runtime.\n            errorMessage = (errorType as (...args: any[]) => string)(\n              messageDetails,\n            );\n          } else {\n            errorMessage = errorType;\n          }\n        }\n\n        if (showError) {\n          diagnostics.push({\n            from,\n            to,\n            severity: 'error',\n            message: '',\n            // FilterField messages embed trusted, internally generated markup (syntax-colored\n            // operators), so they are rendered as HTML rather than escaped text.\n            renderMessage: renderDiagnosticMessage(\n              'error',\n              errorMessage,\n              filterFieldErrorWrapperClass,\n              { dangerouslyRenderHtml: true },\n            ),\n          });\n        }\n      }\n    }\n  }\n\n  if (messages !== undefined) {\n    builder.finish();\n    return diagnostics;\n  }\n\n  return builder.finish();\n}\n\nfunction isErrorInPastingRange(\n  errorFrom: number,\n  errorTo: number,\n  pastingStateField: PastingInfo | undefined,\n) {\n  if (!pastingStateField?.range || !pastingStateField.pastingInProgress) {\n    return false;\n  }\n\n  const pastingRangeFrom = pastingStateField.range.from;\n  const pastingRangeTo = pastingStateField.range.to;\n\n  return (\n    // Check if error starts inside the pasting range\n    // Check if error surrounds the pasting range\n    (errorFrom >= pastingRangeFrom && errorFrom <= pastingRangeTo) ||\n    // Check if error starts inside the pasting range\n    (errorTo >= pastingRangeFrom && errorTo <= pastingRangeFrom) ||\n    (errorFrom <= pastingRangeFrom && errorTo >= pastingRangeTo)\n  );\n}\n"],
   "mappings": "AAEA,SAAS,uBAAuB;AAGhC,SAAS,oCAAoC;AAC7C,SAAS,+BAA+B;AACxC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,OAEK;AAaA,SAAS,4BACd,MACA,UACqC;AACrC,QAAM,UAAU,IAAI,gBAA4B;AAChD,QAAM,cAA4B,CAAC;AACnC,QAAM,mBAAmB,KAAK,MAAM,MAAM,YAAY,KAAK;AAC3D,QAAM,oBAAoB,MAAM,MAAM,MAAM,aAAa,KAAK;AAE9D,MAAI,CAAC,oBAAoB,KAAK,cAAc,WAAW,GAAG;AACxD,QAAI,aAAa,QAAW;AAC1B,cAAQ,OAAO;AACf,aAAO;AAAA,IACT;AAEA,WAAO,QAAQ,OAAO;AAAA,EACxB;AAEA,aAAW,SAAS,iBAAiB,QAAQ;AAC3C,UAAM;AAAA,MACJ,OAAO,EAAE,MAAM,GAAG;AAAA,MAClB;AAAA,MACA,SAAS;AAAA,IACX,IAAI;AACJ,QAAI;AACJ,QAAI;AAEJ,QAAI,OAAO,iBAAiB,UAAU;AACpC,gBAAU;AAAA,IACZ,OAAO;AACL,gBAAU,aAAa;AACvB,uBAAiB,aAAa;AAAA,IAChC;AAEA,QAAI,QAAQ,KAAK,cAAc,CAAC,EAAE,MAAM,MAAM,KAAK,cAAc,CAAC,EAAE,IAAI;AACtE,YAAM,YAAY,CAAC,sBAAsB,MAAM,IAAI,iBAAiB;AAEpE,UAAI,WAAW;AACb,gBAAQ,IAAI,MAAM,IAAI,cAAc,SAAS;AAAA,MAC/C;AAEA,UAAI,aAAa,QAAW;AAC1B,YAAIA,gBAAe;AACnB,cAAM,YAAY,SAAS,OAAyC;AACpE,YAAI,WAAW;AACb,cAAI,OAAO,cAAc,YAAY;AAEnC,YAAAA,gBAAgB;AAAA,cACd;AAAA,YACF;AAAA,UACF,OAAO;AACL,YAAAA,gBAAe;AAAA,UACjB;AAAA,QACF;AAEA,YAAI,WAAW;AACb,sBAAY,KAAK;AAAA,YACf;AAAA,YACA;AAAA,YACA,UAAU;AAAA,YACV,SAAS;AAAA;AAAA;AAAA,YAGT,eAAe;AAAA,cACb;AAAA,cACAA;AAAA,cACA;AAAA,cACA,EAAE,uBAAuB,KAAK;AAAA,YAChC;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,MAAI,aAAa,QAAW;AAC1B,YAAQ,OAAO;AACf,WAAO;AAAA,EACT;AAEA,SAAO,QAAQ,OAAO;AACxB;AAEA,SAAS,sBACP,WACA,SACA,mBACA;AACA,MAAI,CAAC,mBAAmB,SAAS,CAAC,kBAAkB,mBAAmB;AACrE,WAAO;AAAA,EACT;AAEA,QAAM,mBAAmB,kBAAkB,MAAM;AACjD,QAAM,iBAAiB,kBAAkB,MAAM;AAE/C;AAAA;AAAA;AAAA,IAGG,aAAa,oBAAoB,aAAa;AAAA,IAE9C,WAAW,oBAAoB,WAAW,oBAC1C,aAAa,oBAAoB,WAAW;AAAA;AAEjD;",
   "names": ["errorMessage"]
 }

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

@@ -54,6 +54,7 @@ function getSuggestionTransaction(suggestionValue, range, shouldEscapeSuggestion
   let startsWithOperator = false;
   let endsWithOperator = false;
   let hasSpaceAfterQuotes = false;
+  let isWildcardOperatorSwitch = false;
   const followedByOpeningParenthesis = _isFollowedByOpeningBracket(
     editorState,
     head
@@ -74,9 +75,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,
@@ -192,7 +208,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);
   }
@@ -205,8 +221,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;
     }
   };
@@ -249,6 +266,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 };