@dynatrace/strato-components 3.10.4 → 3.11.0

package/esm/filters/filter-field/suggestions/SuggestionsOverlay.sty.js

@@ -1,9 +1,9 @@
 import "./SuggestionsOverlay.css";
-var suggestionsOverlay = "_ssu5rt2-3-10-4";
-var suggestionsOverlayWrapper = "_ssu5rt1-3-10-4";
-var suggestionsOverlayWrapperContainer = "_ssu5rt0-3-10-4";
-var suggestionsScrollContainer = "_ssu5rt4-3-10-4";
-var suggestionsScrollContainerWrapper = "_ssu5rt3-3-10-4";
+var suggestionsOverlay = "_ssu5rt2-3-11-0";
+var suggestionsOverlayWrapper = "_ssu5rt1-3-11-0";
+var suggestionsOverlayWrapperContainer = "_ssu5rt0-3-11-0";
+var suggestionsScrollContainer = "_ssu5rt4-3-11-0";
+var suggestionsScrollContainerWrapper = "_ssu5rt3-3-11-0";
 export {
   suggestionsOverlay,
   suggestionsOverlayWrapper,

package/esm/filters/filter-field/suggestions/SuggestionsOverlay.sty.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/filters/filter-field/suggestions/SuggestionsOverlay.css.ts"],
-  "sourcesContent": ["import './SuggestionsOverlay.css';\nexport var suggestionsOverlay = '_ssu5rt2-3-10-4';\nexport var suggestionsOverlayWrapper = '_ssu5rt1-3-10-4';\nexport var suggestionsOverlayWrapperContainer = '_ssu5rt0-3-10-4';\nexport var suggestionsScrollContainer = '_ssu5rt4-3-10-4';\nexport var suggestionsScrollContainerWrapper = '_ssu5rt3-3-10-4';"],
+  "sourcesContent": ["import './SuggestionsOverlay.css';\nexport var suggestionsOverlay = '_ssu5rt2-3-11-0';\nexport var suggestionsOverlayWrapper = '_ssu5rt1-3-11-0';\nexport var suggestionsOverlayWrapperContainer = '_ssu5rt0-3-11-0';\nexport var suggestionsScrollContainer = '_ssu5rt4-3-11-0';\nexport var suggestionsScrollContainerWrapper = '_ssu5rt3-3-11-0';"],
   "mappings": "AAAA,OAAO;AACA,IAAI,qBAAqB;AACzB,IAAI,4BAA4B;AAChC,IAAI,qCAAqC;AACzC,IAAI,6BAA6B;AACjC,IAAI,oCAAoC;",
   "names": []
 }

package/esm/filters/filter-field/types/dql-conversion-nodes.js

@@ -0,0 +1 @@
+//# sourceMappingURL=dql-conversion-nodes.js.map

package/esm/filters/filter-field/types/dql-conversion-nodes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/esm/filters/filter-field/utils/compute-minimal-doc-change.js

@@ -0,0 +1,20 @@
+function computeMinimalDocChange(oldDoc, newDoc) {
+  const maxCommon = Math.min(oldDoc.length, newDoc.length);
+  let prefix = 0;
+  while (prefix < maxCommon && oldDoc[prefix] === newDoc[prefix]) {
+    prefix++;
+  }
+  let suffix = 0;
+  while (suffix < maxCommon - prefix && oldDoc[oldDoc.length - 1 - suffix] === newDoc[newDoc.length - 1 - suffix]) {
+    suffix++;
+  }
+  return {
+    from: prefix,
+    to: oldDoc.length - suffix,
+    insert: newDoc.slice(prefix, newDoc.length - suffix)
+  };
+}
+export {
+  computeMinimalDocChange
+};
+//# sourceMappingURL=compute-minimal-doc-change.js.map

package/esm/filters/filter-field/utils/compute-minimal-doc-change.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/filters/filter-field/utils/compute-minimal-doc-change.ts"],
+  "sourcesContent": ["/**\n * Computes the minimal change (a single replaced range) that turns `oldDoc`\n * into `newDoc` by trimming the shared prefix and suffix. Dispatching this\n * instead of replacing the whole document from position 0 keeps CodeMirror's\n * contentEditable caret in sync with the editor state: a full `from: 0`\n * replacement rebuilds the content DOM and can leave the native caret behind\n * an interior space, causing the next keystroke to land at the wrong position.\n *\n * @internal\n */\nexport function computeMinimalDocChange(\n  oldDoc: string,\n  newDoc: string,\n): { from: number; to: number; insert: string } {\n  const maxCommon = Math.min(oldDoc.length, newDoc.length);\n\n  let prefix = 0;\n  while (prefix < maxCommon && oldDoc[prefix] === newDoc[prefix]) {\n    prefix++;\n  }\n\n  let suffix = 0;\n  while (\n    suffix < maxCommon - prefix &&\n    oldDoc[oldDoc.length - 1 - suffix] === newDoc[newDoc.length - 1 - suffix]\n  ) {\n    suffix++;\n  }\n\n  return {\n    from: prefix,\n    to: oldDoc.length - suffix,\n    insert: newDoc.slice(prefix, newDoc.length - suffix),\n  };\n}\n"],
+  "mappings": "AAUO,SAAS,wBACd,QACA,QAC8C;AAC9C,QAAM,YAAY,KAAK,IAAI,OAAO,QAAQ,OAAO,MAAM;AAEvD,MAAI,SAAS;AACb,SAAO,SAAS,aAAa,OAAO,MAAM,MAAM,OAAO,MAAM,GAAG;AAC9D;AAAA,EACF;AAEA,MAAI,SAAS;AACb,SACE,SAAS,YAAY,UACrB,OAAO,OAAO,SAAS,IAAI,MAAM,MAAM,OAAO,OAAO,SAAS,IAAI,MAAM,GACxE;AACA;AAAA,EACF;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,IAAI,OAAO,SAAS;AAAA,IACpB,QAAQ,OAAO,MAAM,QAAQ,OAAO,SAAS,MAAM;AAAA,EACrD;AACF;",
+  "names": []
+}

package/esm/filters/filter-field/utils/conversion/dql-conversion/escape-dql.js

@@ -0,0 +1,20 @@
+const BARE_IDENTIFIER_REGEX = /^[a-zA-Z_][a-zA-Z0-9_.]*$/;
+function escapeDqlStringContent(value) {
+  return value.replaceAll("\\", String.raw`\\`).replaceAll('"', String.raw`\"`);
+}
+function escapeDqlIdentifier(identifier) {
+  if (BARE_IDENTIFIER_REGEX.test(identifier)) {
+    return identifier;
+  }
+  const escaped = identifier.replaceAll("\\", String.raw`\\`).replaceAll("`", String.raw`\``);
+  return `\`${escaped}\``;
+}
+function escapeDqlStringLiteral(value) {
+  return `"${escapeDqlStringContent(value)}"`;
+}
+export {
+  escapeDqlIdentifier,
+  escapeDqlStringContent,
+  escapeDqlStringLiteral
+};
+//# sourceMappingURL=escape-dql.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/filters/filter-field/utils/conversion/dql-conversion/escape-dql.ts"],
+  "sourcesContent": ["/**\n * A valid Grail bare identifier starts with `a-zA-Z_` and its body is all `a-zA-Z0-9_.`.\n * Anything else must be backtick-wrapped.\n */\nconst BARE_IDENTIFIER_REGEX = /^[a-zA-Z_][a-zA-Z0-9_.]*$/;\n\n/**\n * Escapes the content of a double-quoted DQL literal without adding the surrounding quotes:\n * backslash becomes `\\\\` and double quote becomes `\\\"` (backslash first). Nothing else is\n * escaped \u2014 a `*` stays a literal wildcard and backtick, single quote and `$` are literal\n * inside double quotes.\n * @param value - Raw string content to escape.\n * @returns Escaped string content, suitable for embedding between double quotes.\n * @internal\n */\nexport function escapeDqlStringContent(value: string): string {\n  return value.replaceAll('\\\\', String.raw`\\\\`).replaceAll('\"', String.raw`\\\"`);\n}\n\n/**\n * Returns a DQL-ready identifier: unquoted when the name is a valid Grail bare\n * identifier (`a-zA-Z_` start, `a-zA-Z0-9_.` body); otherwise backtick-wrapped, with any\n * literal backtick or backslash inside escaped. Use in `overrides` callbacks to escape\n * keys consistently with the default mapping.\n * @param identifier - The field/key name to escape.\n * @returns DQL-safe identifier string, either bare or backtick-wrapped.\n * @public\n */\nexport function escapeDqlIdentifier(identifier: string): string {\n  if (BARE_IDENTIFIER_REGEX.test(identifier)) {\n    return identifier;\n  }\n\n  const escaped = identifier\n    .replaceAll('\\\\', String.raw`\\\\`)\n    .replaceAll('`', String.raw`\\``);\n  return `\\`${escaped}\\``;\n}\n\n/**\n * Returns a DQL-ready string literal: escapes `\\` \u2192 `\\\\` and `\"` \u2192 `\\\"` inside the\n * value and wraps it in double quotes. Use in `overrides` callbacks to escape string\n * values consistently with the default mapping.\n * @param value - Raw string value to escape and quote.\n * @returns DQL-safe double-quoted string literal.\n * @public\n */\nexport function escapeDqlStringLiteral(value: string): string {\n  return `\"${escapeDqlStringContent(value)}\"`;\n}\n"],
+  "mappings": "AAIA,MAAM,wBAAwB;AAWvB,SAAS,uBAAuB,OAAuB;AAC5D,SAAO,MAAM,WAAW,MAAM,OAAO,OAAO,EAAE,WAAW,KAAK,OAAO,OAAO;AAC9E;AAWO,SAAS,oBAAoB,YAA4B;AAC9D,MAAI,sBAAsB,KAAK,UAAU,GAAG;AAC1C,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,WACb,WAAW,MAAM,OAAO,OAAO,EAC/B,WAAW,KAAK,OAAO,OAAO;AACjC,SAAO,KAAK,OAAO;AACrB;AAUO,SAAS,uBAAuB,OAAuB;AAC5D,SAAO,IAAI,uBAAuB,KAAK,CAAC;AAC1C;",
+  "names": []
+}

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

@@ -0,0 +1,243 @@
+import {
+  escapeDqlIdentifier,
+  escapeDqlStringContent,
+  escapeDqlStringLiteral
+} from "./escape-dql.js";
+const RELATIONAL_OPERATORS = /* @__PURE__ */ new Set(["<", "<=", ">", ">="]);
+const DQL_LITERAL_ASTERISK_WILDCARD = "\\uE001";
+function containsLiteralAsterisk(value) {
+  return Array.isArray(value) ? value.some((item) => item.includes("*")) : value.includes("*");
+}
+function getWildcardArgument(value) {
+  return containsLiteralAsterisk(value) ? `, wildcard: "${DQL_LITERAL_ASTERISK_WILDCARD}"` : "";
+}
+function isSingleValue(value) {
+  return value !== void 0 && value.type !== "List" && value.type !== "Error";
+}
+function buildKeyExpression(key, keyMap) {
+  if (!key || key.type === "Error") {
+    return null;
+  }
+  if (key.type === "JSONPath") {
+    const mappedRoot = keyMap?.[key.root];
+    const root = mappedRoot !== void 0 ? mappedRoot : escapeDqlIdentifier(key.root);
+    return `jsonPath(${root}, ${escapeDqlStringLiteral(key.path)})`;
+  }
+  const mappedKey = keyMap?.[key.value];
+  return mappedKey !== void 0 ? mappedKey : escapeDqlIdentifier(key.value);
+}
+function getValueLiteral(value) {
+  switch (value.type) {
+    case "String":
+      return escapeDqlStringLiteral(value.value);
+    case "Number":
+      return `${value.value}`;
+    case "BigInt":
+      return value.value;
+    case "Boolean":
+      return `${value.value}`;
+    case "Duration":
+      return value.value !== void 0 && value.unit ? `${value.value}${value.unit}` : null;
+    case "IPAddress":
+      return `toIp(${escapeDqlStringLiteral(value.value)})`;
+    case "UID":
+      return `toUid(${value.value})`;
+    case "Timestamp":
+      return `toTimestamp(${escapeDqlStringLiteral(value.value)})`;
+    case "SmartscapeId":
+      return `toSmartscapeId(${escapeDqlStringLiteral(value.value)})`;
+    case "Variable":
+      return value.value;
+    default:
+      return null;
+  }
+}
+function getTextValue(value) {
+  switch (value.type) {
+    case "String":
+    case "BigInt":
+    case "IPAddress":
+    case "UID":
+    case "Timestamp":
+    case "SmartscapeId":
+    case "Variable":
+      return value.value;
+    case "Number":
+    case "Boolean":
+      return `${value.value}`;
+    case "Duration":
+      return value.value !== void 0 && value.unit ? `${value.value}${value.unit}` : null;
+    default:
+      return null;
+  }
+}
+function buildDqlPattern(rawValue, operator, wildcard) {
+  const escapedValue = escapeDqlStringContent(rawValue);
+  switch (operator) {
+    case "contains":
+    case "not-contains":
+      return `"${wildcard}${escapedValue}${wildcard}"`;
+    case "starts-with":
+    case "not-starts-with":
+      return `"${escapedValue}${wildcard}"`;
+    case "ends-with":
+    case "not-ends-with":
+      return `"${wildcard}${escapedValue}"`;
+    default:
+      return `"${escapedValue}"`;
+  }
+}
+function buildStringFragment(key, operator, value) {
+  if (RELATIONAL_OPERATORS.has(operator)) {
+    return `${key} ${operator} ${escapeDqlStringLiteral(value)}`;
+  }
+  if (operator === "matches-phrase" || operator === "not-matches-phrase") {
+    return null;
+  }
+  const wildcardArgument = getWildcardArgument(value);
+  const wildcard = wildcardArgument ? DQL_LITERAL_ASTERISK_WILDCARD : "*";
+  const pattern = buildDqlPattern(value, operator, wildcard);
+  const fragment = `matchesValue(${key}, ${pattern}${wildcardArgument})`;
+  return operator === "!=" || operator.startsWith("not-") ? `not ${fragment}` : fragment;
+}
+function buildScalarFragment(key, operator, value) {
+  const literal = getValueLiteral(value);
+  if (literal === null) {
+    return null;
+  }
+  switch (operator) {
+    case "=":
+      return `${key} == ${literal}`;
+    case "!=":
+      return `${key} != ${literal}`;
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+      return `${key} ${operator} ${literal}`;
+    default:
+      return null;
+  }
+}
+function buildInclusionFragment(key, operator, value) {
+  if (value?.type !== "List" || value.value.length === 0) {
+    return null;
+  }
+  const valueLiterals = [];
+  for (const item of value.value) {
+    const literal = getValueLiteral(item);
+    if (literal === null) {
+      return null;
+    }
+    valueLiterals.push(literal);
+  }
+  let fragment;
+  if (value.value.every((item) => item.type === "String")) {
+    const wildcardArgument = getWildcardArgument(valueLiterals);
+    fragment = `matchesValue(${key}, array(${valueLiterals.join(
+      ", "
+    )})${wildcardArgument})`;
+  } else {
+    fragment = `in(${key}, {${valueLiterals.join(", ")}})`;
+  }
+  return operator === "not in" ? `not ${fragment}` : fragment;
+}
+function buildComparisonFragment(key, operator, value) {
+  if (!isSingleValue(value)) {
+    return null;
+  }
+  if (operator === "matches-phrase" || operator === "not-matches-phrase") {
+    const phrase = getTextValue(value);
+    if (phrase === null) {
+      return null;
+    }
+    const wildcardArgument = getWildcardArgument(phrase);
+    const fragment = `matchesPhrase(${key}, ${escapeDqlStringLiteral(
+      phrase
+    )}${wildcardArgument})`;
+    return operator === "not-matches-phrase" ? `not ${fragment}` : fragment;
+  }
+  if (value.type === "String") {
+    return buildStringFragment(key, operator, value.value);
+  }
+  return buildScalarFragment(key, operator, value);
+}
+function buildDefaultFilterFragment(statement, keyMap) {
+  const { key, comparisonOperator, value } = statement;
+  if (!comparisonOperator) {
+    return null;
+  }
+  const keyExpression = buildKeyExpression(key, keyMap);
+  if (keyExpression === null) {
+    return null;
+  }
+  switch (comparisonOperator.type) {
+    // Existence checks are type-agnostic and need no value.
+    case "ExistsOperator":
+      return comparisonOperator.value ? `isNotNull(${keyExpression})` : `isNull(${keyExpression})`;
+    case "InclusionOperator":
+      return buildInclusionFragment(
+        keyExpression,
+        comparisonOperator.value,
+        value
+      );
+    case "ComparisonOperator":
+      return buildComparisonFragment(
+        keyExpression,
+        comparisonOperator.value,
+        value
+      );
+    // Global search is routed to `| search`, not to a filter fragment; missing/invalid (Error)
+    // and other non-operator nodes are not mappable.
+    default:
+      return null;
+  }
+}
+function buildFilterFragment(statement, options) {
+  if (statement.comparisonOperator?.type === "SearchOperator") {
+    return null;
+  }
+  if (options?.overrides) {
+    const override = options.overrides(
+      statement,
+      () => buildDefaultFilterFragment(statement, options.keyMap) ?? ""
+    );
+    if (override !== void 0) {
+      return override;
+    }
+  }
+  return buildDefaultFilterFragment(statement, options?.keyMap);
+}
+function buildDefaultSearchTerm(value, comparisonOperator) {
+  if (value.type === "Variable") {
+    return value.value;
+  }
+  const rawValue = getTextValue(value);
+  if (rawValue === null) {
+    return null;
+  }
+  const operator = comparisonOperator?.type === "ComparisonOperator" || comparisonOperator?.type === "SearchOperator" ? comparisonOperator.value : null;
+  const pattern = buildDqlPattern(rawValue, operator, "*");
+  return pattern;
+}
+function buildSearchTerm(statement, options) {
+  const { comparisonOperator, value } = statement;
+  if (!isSingleValue(value)) {
+    return null;
+  }
+  if (options?.overrides) {
+    const override = options.overrides(
+      statement,
+      () => buildDefaultSearchTerm(value, comparisonOperator) ?? ""
+    );
+    if (override !== void 0) {
+      return override;
+    }
+  }
+  return buildDefaultSearchTerm(value, comparisonOperator);
+}
+export {
+  buildFilterFragment,
+  buildSearchTerm
+};
+//# sourceMappingURL=statement-to-dql-fragments.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/filters/filter-field/utils/conversion/dql-conversion/statement-to-dql-fragments.ts"],
+  "sourcesContent": ["import {\n  escapeDqlIdentifier,\n  escapeDqlStringContent,\n  escapeDqlStringLiteral,\n} from './escape-dql.js';\nimport type {\n  SimpleFilterFieldComparisonOperatorNode,\n  SimpleFilterFieldInclusionOperatorNode,\n  SimpleFilterFieldLeafNode,\n  SimpleFilterFieldSearchOperatorNode,\n  SimpleFilterFieldStatementNode,\n  SimpleFilterFieldValueNode,\n} from '../../../types/conversion-tree-nodes.js';\nimport type { FilterFieldDqlOptions } from '../../../types/dql-conversion-nodes.js';\n\ntype SingleValueNode = Exclude<\n  SimpleFilterFieldValueNode,\n  { type: 'List' | 'Error' }\n>;\n\nconst RELATIONAL_OPERATORS = new Set(['<', '<=', '>', '>=']);\n// U+E001 is used as a wildcard when literal asterisks are present, as it is not expected in user input.\nconst DQL_LITERAL_ASTERISK_WILDCARD = '\\\\uE001';\n\n/**\n * Checks whether pattern values contain a literal `*`. FilterField extracts positional wildcards\n * into the operator, so any `*` that survives in a parsed value is literal.\n * @param value - One pattern value or a list of values to inspect.\n * @returns Whether any value contains a literal asterisk.\n */\nfunction containsLiteralAsterisk(value: string | string[]): boolean {\n  return Array.isArray(value)\n    ? value.some((item) => item.includes('*'))\n    : value.includes('*');\n}\n\n/**\n * Returns the DQL wildcard argument required to preserve literal asterisks in pattern values.\n * @param value - One pattern value or a list of values to inspect.\n * @returns The wildcard argument, or an empty string when the default `*` wildcard is safe.\n */\nfunction getWildcardArgument(value: string | string[]): string {\n  return containsLiteralAsterisk(value)\n    ? `, wildcard: \"${DQL_LITERAL_ASTERISK_WILDCARD}\"`\n    : '';\n}\n\n/**\n * Narrows a statement value to a single, non-error node (not `List`, not `Error`, not `undefined`).\n * @param value - The statement value to check.\n * @returns `true` for non-list, non-error values.\n */\nfunction isSingleValue(\n  value: SimpleFilterFieldValueNode | undefined,\n): value is SingleValueNode {\n  return value !== undefined && value.type !== 'List' && value.type !== 'Error';\n}\n\n/**\n * Builds a DQL expression for a statement's key, applying `keyMap` before escaping.\n * Plain keys become escaped identifiers; JSONPath keys become\n * `jsonPath(<root>, <path>)` expressions with the root subject to `keyMap` remapping.\n * Keys resolved via `keyMap` are emitted verbatim \u2014 the consumer is responsible for escaping.\n * @param key - The statement key node.\n * @param keyMap - Optional field rename map.\n * @returns DQL expression string, or `null` for a missing/invalid (Error) key.\n */\nfunction buildKeyExpression(\n  key: SimpleFilterFieldStatementNode['key'],\n  keyMap: FilterFieldDqlOptions['keyMap'],\n): string | null {\n  if (!key || key.type === 'Error') {\n    return null;\n  }\n\n  if (key.type === 'JSONPath') {\n    const mappedRoot = keyMap?.[key.root];\n    const root =\n      mappedRoot !== undefined ? mappedRoot : escapeDqlIdentifier(key.root);\n    return `jsonPath(${root}, ${escapeDqlStringLiteral(key.path)})`;\n  }\n\n  const mappedKey = keyMap?.[key.value];\n  return mappedKey !== undefined ? mappedKey : escapeDqlIdentifier(key.value);\n}\n\n/**\n * Gets a single leaf value node's DQL literal. Returns `null` for value types that\n * have no literal representation (Error nodes, operators, keys).\n * @param value - A leaf value node.\n * @returns DQL literal string, or `null` for types with no literal representation.\n */\nfunction getValueLiteral(value: SimpleFilterFieldLeafNode): string | null {\n  switch (value.type) {\n    case 'String':\n      return escapeDqlStringLiteral(value.value);\n    case 'Number':\n      return `${value.value}`;\n    case 'BigInt':\n      return value.value;\n    case 'Boolean':\n      return `${value.value}`;\n    case 'Duration':\n      return value.value !== undefined && value.unit\n        ? `${value.value}${value.unit}`\n        : null;\n    case 'IPAddress':\n      return `toIp(${escapeDqlStringLiteral(value.value)})`;\n    case 'UID':\n      return `toUid(${value.value})`;\n    case 'Timestamp':\n      return `toTimestamp(${escapeDqlStringLiteral(value.value)})`;\n    case 'SmartscapeId':\n      return `toSmartscapeId(${escapeDqlStringLiteral(value.value)})`;\n    case 'Variable':\n      // A query variable is a reference resolved at execution time, passed through verbatim.\n      return value.value;\n    default:\n      return null;\n  }\n}\n\n/**\n * Gets a value's raw string content for phrase/search contexts.\n * @param value - A single statement value node.\n * @returns Raw string content, or `null` for incomplete/non-value nodes.\n */\nfunction getTextValue(value: SingleValueNode): string | null {\n  switch (value.type) {\n    case 'String':\n    case 'BigInt':\n    case 'IPAddress':\n    case 'UID':\n    case 'Timestamp':\n    case 'SmartscapeId':\n    case 'Variable':\n      return value.value;\n    case 'Number':\n    case 'Boolean':\n      return `${value.value}`;\n    case 'Duration':\n      return value.value !== undefined && value.unit\n        ? `${value.value}${value.unit}`\n        : null;\n    default:\n      return null;\n  }\n}\n\n/**\n * Builds a quoted DQL pattern with the positional wildcard semantics of an operator.\n * Operators without positional wildcard semantics only escape the raw value.\n * @param rawValue - Raw pattern value.\n * @param operator - The comparison or search operator value.\n * @param wildcard - Wildcard character to add to the pattern.\n * @returns An escaped DQL pattern with surrounding quotes.\n */\nfunction buildDqlPattern(\n  rawValue: string,\n  operator:\n    | SimpleFilterFieldComparisonOperatorNode['value']\n    | SimpleFilterFieldSearchOperatorNode['value']\n    | null,\n  wildcard: string,\n): string {\n  const escapedValue = escapeDqlStringContent(rawValue);\n\n  switch (operator) {\n    case 'contains':\n    case 'not-contains':\n      return `\"${wildcard}${escapedValue}${wildcard}\"`;\n    case 'starts-with':\n    case 'not-starts-with':\n      return `\"${escapedValue}${wildcard}\"`;\n    case 'ends-with':\n    case 'not-ends-with':\n      return `\"${wildcard}${escapedValue}\"`;\n    default:\n      return `\"${escapedValue}\"`;\n  }\n}\n\n/**\n * Builds a String statement fragment. Relational operators produce a literal string comparison;\n * everything else produces `matchesValue(key, \"glob*\")` with wildcards from the operator.\n * A surviving `*` in `rawValue` is always literal (real wildcards are extracted into the\n * operator).\n * @param key - Escaped DQL key expression.\n * @param operator - The comparison operator value.\n * @param value - String value from the statement.\n * @returns DQL fragment string, or `null` for unmappable operators.\n */\nfunction buildStringFragment(\n  key: string,\n  operator: SimpleFilterFieldComparisonOperatorNode['value'],\n  value: string,\n): string | null {\n  if (RELATIONAL_OPERATORS.has(operator)) {\n    return `${key} ${operator} ${escapeDqlStringLiteral(value)}`;\n  }\n  if (operator === 'matches-phrase' || operator === 'not-matches-phrase') {\n    return null;\n  }\n\n  // If the string contains a `*`, change the wildcard character\n  const wildcardArgument = getWildcardArgument(value);\n  const wildcard = wildcardArgument ? DQL_LITERAL_ASTERISK_WILDCARD : '*';\n  const pattern = buildDqlPattern(value, operator, wildcard);\n  const fragment = `matchesValue(${key}, ${pattern}${wildcardArgument})`;\n  // Negate the expression for `!=` and negated position operators\n  return operator === '!=' || operator.startsWith('not-')\n    ? `not ${fragment}`\n    : fragment;\n}\n\n/**\n * Builds a non-String scalar statement fragment using type-correct comparison operators and a coerced value literal.\n * IPAddress, UID, Timestamp, SmartscapeId include a type-coercion call.\n * @param key - Escaped DQL key expression.\n * @param operator - The comparison operator value.\n * @param value - A leaf value node with a known non-String type.\n * @returns DQL fragment string, or `null` for unmappable operators or non-convertible values.\n */\nfunction buildScalarFragment(\n  key: string,\n  operator: SimpleFilterFieldComparisonOperatorNode['value'],\n  value: SimpleFilterFieldLeafNode,\n): string | null {\n  const literal = getValueLiteral(value);\n  if (literal === null) {\n    return null;\n  }\n\n  switch (operator) {\n    case '=':\n      return `${key} == ${literal}`;\n    case '!=':\n      return `${key} != ${literal}`;\n    case '<':\n    case '<=':\n    case '>':\n    case '>=':\n      return `${key} ${operator} ${literal}`;\n    default:\n      // Position / phrase operators are not valid on non-String typed values.\n      return null;\n  }\n}\n\n/**\n * Builds an inclusion statement fragment (`in` / `not in`). All-String lists use\n * `matchesValue(key, array(...))`; any other (including mixed or variable-containing) lists use\n * the type-agnostic `in(key, {...})` set form.\n * @param key - Escaped DQL key expression.\n * @param operator - `'in'` or `'not in'`.\n * @param value - The value node (expected to be a non-empty List).\n * @returns DQL fragment string, or `null` for empty/invalid lists.\n */\nfunction buildInclusionFragment(\n  key: string,\n  operator: SimpleFilterFieldInclusionOperatorNode['value'],\n  value: SimpleFilterFieldValueNode | undefined,\n): string | null {\n  if (value?.type !== 'List' || value.value.length === 0) {\n    return null;\n  }\n\n  const valueLiterals: string[] = [];\n  for (const item of value.value) {\n    const literal = getValueLiteral(item);\n    if (literal === null) {\n      return null;\n    }\n    valueLiterals.push(literal);\n  }\n\n  let fragment: string;\n  if (value.value.every((item) => item.type === 'String')) {\n    // A `*` in a String item is literal, so change the wildcard character for the whole pattern.\n    const wildcardArgument = getWildcardArgument(valueLiterals);\n    fragment = `matchesValue(${key}, array(${valueLiterals.join(\n      ', ',\n    )})${wildcardArgument})`;\n  } else {\n    // Mixed and typed do not use pattern matching.\n    fragment = `in(${key}, {${valueLiterals.join(', ')}})`;\n  }\n\n  return operator === 'not in' ? `not ${fragment}` : fragment;\n}\n\n/**\n * Builds a `ComparisonOperator` statement fragment, routing by value type.\n * Phrase operators always produce a `matchesPhrase` string (coercing non-String scalars so any\n * error-free FilterField input still maps); String values use `matchesValue` with wildcard /\n * relational handling; all other scalar types use a type-correct comparison.\n * @param key - Escaped DQL key expression.\n * @param operator - The comparison operator value.\n * @param value - The statement value node.\n * @returns DQL fragment string, or `null` for missing/list/error values or unmappable operators.\n */\nfunction buildComparisonFragment(\n  key: string,\n  operator: SimpleFilterFieldComparisonOperatorNode['value'],\n  value: SimpleFilterFieldValueNode | undefined,\n): string | null {\n  if (!isSingleValue(value)) {\n    return null;\n  }\n\n  if (operator === 'matches-phrase' || operator === 'not-matches-phrase') {\n    const phrase = getTextValue(value);\n    if (phrase === null) {\n      return null;\n    }\n\n    // `matchesPhrase` treats `*` as a wildcard too.\n    // If `*` is present, use a different wildcard character to preserve it.\n    const wildcardArgument = getWildcardArgument(phrase);\n    const fragment = `matchesPhrase(${key}, ${escapeDqlStringLiteral(\n      phrase,\n    )}${wildcardArgument})`;\n    return operator === 'not-matches-phrase' ? `not ${fragment}` : fragment;\n  }\n\n  if (value.type === 'String') {\n    return buildStringFragment(key, operator, value.value);\n  }\n\n  return buildScalarFragment(key, operator, value);\n}\n\n/**\n * Produces the default DQL filter fragment for a statement (with `keyMap` applied).\n * @param statement - The statement node.\n * @param keyMap - Optional field rename map.\n * @returns DQL filter fragment string, or `null` for search/unmappable statements.\n */\nfunction buildDefaultFilterFragment(\n  statement: SimpleFilterFieldStatementNode,\n  keyMap: FilterFieldDqlOptions['keyMap'],\n): string | null {\n  const { key, comparisonOperator, value } = statement;\n\n  if (!comparisonOperator) {\n    return null;\n  }\n\n  const keyExpression = buildKeyExpression(key, keyMap);\n  if (keyExpression === null) {\n    return null;\n  }\n\n  switch (comparisonOperator.type) {\n    // Existence checks are type-agnostic and need no value.\n    case 'ExistsOperator':\n      return comparisonOperator.value\n        ? `isNotNull(${keyExpression})`\n        : `isNull(${keyExpression})`;\n\n    case 'InclusionOperator':\n      return buildInclusionFragment(\n        keyExpression,\n        comparisonOperator.value,\n        value,\n      );\n\n    case 'ComparisonOperator':\n      return buildComparisonFragment(\n        keyExpression,\n        comparisonOperator.value,\n        value,\n      );\n\n    // Global search is routed to `| search`, not to a filter fragment; missing/invalid (Error)\n    // and other non-operator nodes are not mappable.\n    default:\n      return null;\n  }\n}\n\n/**\n * Resolves a statement's filter fragment.\n * Checks first if an override is defined, otherwise uses the built-in default.\n * @param statement - The statement node.\n * @param options - Optional conversion options including `keyMap` and `overrides`.\n * @returns DQL filter fragment string, or `null` for search/unmappable statements.\n * @internal\n */\nexport function buildFilterFragment(\n  statement: SimpleFilterFieldStatementNode,\n  options?: FilterFieldDqlOptions,\n): string | null {\n  // Search statements route to `| search` only \u2014 never produce a filter fragment.\n  if (statement.comparisonOperator?.type === 'SearchOperator') {\n    return null;\n  }\n\n  if (options?.overrides) {\n    const override = options.overrides(\n      statement,\n      () => buildDefaultFilterFragment(statement, options.keyMap) ?? '',\n    );\n    if (override !== undefined) {\n      return override;\n    }\n  }\n\n  return buildDefaultFilterFragment(statement, options?.keyMap);\n}\n\n/**\n * Produces the default DQL search term for a global-search statement.\n * Variables are emitted unquoted; all other values are quoted, preserving any wildcards the user\n * entered.\n * @param value - The resolved single value node (pre-checked by the caller).\n * @param comparisonOperator - The statement's operator node, used to apply positional wildcards.\n * @returns DQL search term string, or `null` for incomplete/non-convertible values.\n */\nfunction buildDefaultSearchTerm(\n  value: SingleValueNode,\n  comparisonOperator: SimpleFilterFieldStatementNode['comparisonOperator'],\n): string | null {\n  // A variable is a runtime reference \u2014 quoting it turns it into a string literal.\n  if (value.type === 'Variable') {\n    return value.value;\n  }\n\n  const rawValue = getTextValue(value);\n  if (rawValue === null) {\n    return null;\n  }\n\n  // `* ~ *test` extracts the wildcard into a position operator on the search operator's value;\n  // `* ~ test` keeps the operator value as `search`.\n  const operator =\n    comparisonOperator?.type === 'ComparisonOperator' ||\n    comparisonOperator?.type === 'SearchOperator'\n      ? comparisonOperator.value\n      : null;\n  const pattern = buildDqlPattern(rawValue, operator, '*');\n\n  // DQL `search` has no `wildcard` argument, so a literal `*` (from `\\*` as FF input) cannot be escaped.\n  return pattern;\n}\n\n/**\n * Builds a global-search statement's `| search` term. Variables are emitted unquoted; all other\n * values are quoted, preserving any wildcards the user entered.\n * When `options.overrides` is provided it takes precedence over the default mapping.\n * @param statement - A global-search (`* ~`) statement node.\n * @param options - Optional conversion options including `overrides`.\n * @returns DQL search term string, or `null` for missing/invalid values.\n * @internal\n */\nexport function buildSearchTerm(\n  statement: SimpleFilterFieldStatementNode,\n  options?: FilterFieldDqlOptions,\n): string | null {\n  const { comparisonOperator, value } = statement;\n  if (!isSingleValue(value)) {\n    return null;\n  }\n\n  if (options?.overrides) {\n    const override = options.overrides(\n      statement,\n      () => buildDefaultSearchTerm(value, comparisonOperator) ?? '',\n    );\n    if (override !== undefined) {\n      return override;\n    }\n  }\n\n  return buildDefaultSearchTerm(value, comparisonOperator);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,103 @@
+import {
+  buildSearchTerm,
+  buildFilterFragment
+} from "./statement-to-dql-fragments.js";
+import { devLog } from "../../../../../core/utils/logging.js";
+import {
+  isFilterFieldGroupNode,
+  isFilterFieldStatementNode
+} from "../../tree-node-guards.js";
+function isCompleteAndValidStatement(statement) {
+  const { key, comparisonOperator, value } = statement;
+  if (!key || key.type === "Error") {
+    return false;
+  }
+  if (!comparisonOperator || comparisonOperator.type === "Error") {
+    return false;
+  }
+  if (comparisonOperator.type === "ExistsOperator") {
+    return true;
+  }
+  if (!value || value.type === "Error") {
+    return false;
+  }
+  if (value.type === "List" && value.value.length === 0) {
+    return false;
+  }
+  return true;
+}
+function enrichStatement(statement, options) {
+  const filterDql = buildFilterFragment(statement, options);
+  if (filterDql === null && statement.comparisonOperator?.type !== "SearchOperator" && isCompleteAndValidStatement(statement)) {
+    devLog(
+      "FilterField \u2192 DQL: a statement could not be mapped to a DQL fragment and was omitted.",
+      statement
+    );
+  }
+  return { ...statement, filterDql };
+}
+function getSearchTerm(child, options) {
+  if (child.type === "Group") {
+    return child.searchDql;
+  }
+  if (child.comparisonOperator?.type === "SearchOperator") {
+    return buildSearchTerm(child, options);
+  }
+  return null;
+}
+function enrichGroup(group, options) {
+  const children = group.children.map((child) => enrichNode(child, options)).filter((child) => child !== void 0);
+  const logicalOperator = ` ${group.logicalOperator.toLowerCase()} `;
+  const filterFragments = [];
+  const searchTerms = [];
+  for (const child of children) {
+    if (child.filterDql) {
+      filterFragments.push(child.filterDql);
+    }
+    const term = getSearchTerm(child, options);
+    if (term) {
+      searchTerms.push(term);
+    }
+  }
+  let filterDql = null;
+  if (filterFragments.length > 0) {
+    const joined = filterFragments.join(logicalOperator);
+    filterDql = group.explicit ? `(${joined})` : joined;
+  }
+  const searchDql = searchTerms.length > 0 ? searchTerms.join(logicalOperator) : null;
+  return { ...group, children, filterDql, searchDql };
+}
+function enrichNode(node, options) {
+  if (isFilterFieldGroupNode(node)) {
+    return enrichGroup(node, options);
+  }
+  if (isFilterFieldStatementNode(node)) {
+    return enrichStatement(node, options);
+  }
+  return void 0;
+}
+function enrichFilterFieldTreeWithDql(tree, options) {
+  if (!tree) {
+    return void 0;
+  }
+  return enrichGroup(tree, options);
+}
+function convertFilterFieldTreeToDql(tree, options) {
+  const dqlTree = enrichFilterFieldTreeWithDql(tree, options);
+  if (!dqlTree) {
+    return "";
+  }
+  const parts = [];
+  if (dqlTree.filterDql) {
+    parts.push(`| filter ${dqlTree.filterDql}`);
+  }
+  if (dqlTree.searchDql) {
+    parts.push(`| search ${dqlTree.searchDql}`);
+  }
+  return parts.join(" ");
+}
+export {
+  convertFilterFieldTreeToDql,
+  enrichFilterFieldTreeWithDql
+};
+//# sourceMappingURL=tree-dql-conversion.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/filters/filter-field/utils/conversion/dql-conversion/tree-dql-conversion.ts"],
+  "sourcesContent": ["import {\n  buildSearchTerm,\n  buildFilterFragment,\n} from './statement-to-dql-fragments.js';\nimport { devLog } from '../../../../../core/utils/logging.js';\nimport type {\n  SimpleFilterFieldGroupNode,\n  SimpleFilterFieldNode,\n  SimpleFilterFieldStatementNode,\n  SimpleFilterFieldTree,\n} from '../../../types/conversion-tree-nodes.js';\nimport type {\n  FilterFieldDqlGroupNode,\n  FilterFieldDqlNode,\n  FilterFieldDqlOptions,\n  FilterFieldDqlStatementNode,\n  FilterFieldDqlTree,\n} from '../../../types/dql-conversion-nodes.js';\nimport {\n  isFilterFieldGroupNode,\n  isFilterFieldStatementNode,\n} from '../../tree-node-guards.js';\n\n/**\n * A statement is only worth warning about when it looks complete but still produced no fragment \u2014\n * that signals a genuine mapping gap. Incomplete statements (missing/erroring parts) are expected\n * while the user is typing and are silently skipped.\n * @param statement - The statement node to evaluate.\n * @returns `true` when all required parts (key, operator, value) are present and non-error.\n */\nfunction isCompleteAndValidStatement(\n  statement: SimpleFilterFieldStatementNode,\n): boolean {\n  const { key, comparisonOperator, value } = statement;\n  if (!key || key.type === 'Error') {\n    return false;\n  }\n  if (!comparisonOperator || comparisonOperator.type === 'Error') {\n    return false;\n  }\n  if (comparisonOperator.type === 'ExistsOperator') {\n    return true;\n  }\n  if (!value || value.type === 'Error') {\n    return false;\n  }\n  if (value.type === 'List' && value.value.length === 0) {\n    return false;\n  }\n  return true;\n}\n\n/**\n * Adds `filterDql` to a statement node. Logs a dev warning when the statement is complete\n * but produces no fragment, signalling a genuine mapping gap rather than mid-type incompleteness.\n * @param statement - The source statement node.\n * @param options - Optional conversion options.\n * @returns The enriched statement node with `filterDql` attached.\n */\nfunction enrichStatement(\n  statement: SimpleFilterFieldStatementNode,\n  options?: FilterFieldDqlOptions,\n): FilterFieldDqlStatementNode {\n  const filterDql = buildFilterFragment(statement, options);\n\n  if (\n    filterDql === null &&\n    statement.comparisonOperator?.type !== 'SearchOperator' &&\n    isCompleteAndValidStatement(statement)\n  ) {\n    devLog(\n      'FilterField \u2192 DQL: a statement could not be mapped to a DQL fragment and was omitted.',\n      statement,\n    );\n  }\n\n  return { ...statement, filterDql };\n}\n\n/**\n * Returns the search-term contribution of a group node: the aggregated `searchDql` for a\n * sub-group, the built term for a `SearchOperator` statement, or `null` for all other nodes.\n * @param child - An enriched child node from a group's `children` array.\n * @param options - Optional conversion options forwarded to {@link buildSearchTerm}.\n */\nfunction getSearchTerm(\n  child: FilterFieldDqlNode,\n  options?: FilterFieldDqlOptions,\n): string | null {\n  if (child.type === 'Group') {\n    return child.searchDql;\n  }\n  if (child.comparisonOperator?.type === 'SearchOperator') {\n    return buildSearchTerm(child, options);\n  }\n  return null;\n}\n\n/**\n * Recursively enriches all children, then aggregates their `filterDql` and `searchDql` values\n * into the group's own expressions. Explicit groups wrap their filter fragment in parentheses.\n * @param group - The source group node.\n * @param options - Optional conversion options.\n * @returns The enriched group node with `children`, `filterDql`, and `searchDql` attached.\n */\nfunction enrichGroup(\n  group: SimpleFilterFieldGroupNode,\n  options?: FilterFieldDqlOptions,\n): FilterFieldDqlGroupNode {\n  const children: FilterFieldDqlNode[] = group.children\n    .map((child) => enrichNode(child, options))\n    .filter((child): child is FilterFieldDqlNode => child !== undefined);\n\n  const logicalOperator = ` ${group.logicalOperator.toLowerCase()} `;\n\n  // gather filter fragments and search terms from children\n  const filterFragments: string[] = [];\n  const searchTerms: string[] = [];\n  for (const child of children) {\n    if (child.filterDql) {\n      filterFragments.push(child.filterDql);\n    }\n    const term = getSearchTerm(child, options);\n    if (term) {\n      searchTerms.push(term);\n    }\n  }\n\n  // enrich the group with its own filterDql and searchDql, aggregated from children\n  let filterDql: string | null = null;\n  if (filterFragments.length > 0) {\n    const joined = filterFragments.join(logicalOperator);\n    // Only the group the user explicitly parenthesized is wrapped; the root is never explicit.\n    filterDql = group.explicit ? `(${joined})` : joined;\n  }\n\n  const searchDql: string | null =\n    searchTerms.length > 0 ? searchTerms.join(logicalOperator) : null;\n\n  return { ...group, children, filterDql, searchDql };\n}\n\n/**\n * Dispatches to {@link enrichGroup} or {@link enrichStatement} based on node type.\n * `SimpleFilterFieldNode` also covers List/Leaf variants \u2014 a bare `Error` node can appear\n * as a direct group child (e.g. an unclosed or empty group) while the user is mid-typing.\n * Such nodes have no DQL representation of their own and are dropped.\n * @param node - The source node.\n * @param options - Optional conversion options.\n * @returns The enriched node, or `undefined` when the node is neither a Group nor a Statement.\n */\nfunction enrichNode(\n  node: SimpleFilterFieldNode,\n  options?: FilterFieldDqlOptions,\n): FilterFieldDqlNode | undefined {\n  if (isFilterFieldGroupNode(node)) {\n    return enrichGroup(node, options);\n  }\n  if (isFilterFieldStatementNode(node)) {\n    return enrichStatement(node, options);\n  }\n  return undefined;\n}\n\n/**\n * Returns the input tree with `filterDql` added to every node and `searchDql` added to\n * every group and the root. Statement nodes get `filterDql: null` when unmappable or\n * when the statement is a global-search (`* ~`) \u2014 its term is aggregated into the\n * enclosing groups' `searchDql` instead.\n * @param tree - The source filter field tree.\n * @param options - Optional `keyMap` and `overrides` to customize the DQL mapping.\n * @returns The enriched tree, or `undefined` for an empty tree.\n * @public\n */\nexport function enrichFilterFieldTreeWithDql(\n  tree: SimpleFilterFieldTree,\n  options?: FilterFieldDqlOptions,\n): FilterFieldDqlTree {\n  if (!tree) {\n    return undefined;\n  }\n\n  return enrichGroup(tree, options);\n}\n\n/**\n * Returns a ready-to-use DQL statement: `| filter <expression>` for filter statements\n * followed by `| search <terms>` for global-search (`* ~`) statements. Either command is\n * omitted when it has no content; returns an empty string for an empty tree.\n * @param tree - The source filter field tree.\n * @param options - Optional `keyMap` and `overrides` to customize the DQL mapping.\n * @returns A DQL pipeline fragment (e.g. `| filter \u2026 | search \u2026`), or `''` for an empty tree.\n * @public\n */\nexport function convertFilterFieldTreeToDql(\n  tree: SimpleFilterFieldTree,\n  options?: FilterFieldDqlOptions,\n): string {\n  const dqlTree = enrichFilterFieldTreeWithDql(tree, options);\n\n  // empty tree\n  if (!dqlTree) {\n    return '';\n  }\n\n  const parts: string[] = [];\n\n  // gather filter and search statements\n  if (dqlTree.filterDql) {\n    parts.push(`| filter ${dqlTree.filterDql}`);\n  }\n  if (dqlTree.searchDql) {\n    parts.push(`| search ${dqlTree.searchDql}`);\n  }\n\n  return parts.join(' ');\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc;AAcvB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AASP,SAAS,4BACP,WACS;AACT,QAAM,EAAE,KAAK,oBAAoB,MAAM,IAAI;AAC3C,MAAI,CAAC,OAAO,IAAI,SAAS,SAAS;AAChC,WAAO;AAAA,EACT;AACA,MAAI,CAAC,sBAAsB,mBAAmB,SAAS,SAAS;AAC9D,WAAO;AAAA,EACT;AACA,MAAI,mBAAmB,SAAS,kBAAkB;AAChD,WAAO;AAAA,EACT;AACA,MAAI,CAAC,SAAS,MAAM,SAAS,SAAS;AACpC,WAAO;AAAA,EACT;AACA,MAAI,MAAM,SAAS,UAAU,MAAM,MAAM,WAAW,GAAG;AACrD,WAAO;AAAA,EACT;AACA,SAAO;AACT;AASA,SAAS,gBACP,WACA,SAC6B;AAC7B,QAAM,YAAY,oBAAoB,WAAW,OAAO;AAExD,MACE,cAAc,QACd,UAAU,oBAAoB,SAAS,oBACvC,4BAA4B,SAAS,GACrC;AACA;AAAA,MACE;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAE,GAAG,WAAW,UAAU;AACnC;AAQA,SAAS,cACP,OACA,SACe;AACf,MAAI,MAAM,SAAS,SAAS;AAC1B,WAAO,MAAM;AAAA,EACf;AACA,MAAI,MAAM,oBAAoB,SAAS,kBAAkB;AACvD,WAAO,gBAAgB,OAAO,OAAO;AAAA,EACvC;AACA,SAAO;AACT;AASA,SAAS,YACP,OACA,SACyB;AACzB,QAAM,WAAiC,MAAM,SAC1C,IAAI,CAAC,UAAU,WAAW,OAAO,OAAO,CAAC,EACzC,OAAO,CAAC,UAAuC,UAAU,MAAS;AAErE,QAAM,kBAAkB,IAAI,MAAM,gBAAgB,YAAY,CAAC;AAG/D,QAAM,kBAA4B,CAAC;AACnC,QAAM,cAAwB,CAAC;AAC/B,aAAW,SAAS,UAAU;AAC5B,QAAI,MAAM,WAAW;AACnB,sBAAgB,KAAK,MAAM,SAAS;AAAA,IACtC;AACA,UAAM,OAAO,cAAc,OAAO,OAAO;AACzC,QAAI,MAAM;AACR,kBAAY,KAAK,IAAI;AAAA,IACvB;AAAA,EACF;AAGA,MAAI,YAA2B;AAC/B,MAAI,gBAAgB,SAAS,GAAG;AAC9B,UAAM,SAAS,gBAAgB,KAAK,eAAe;AAEnD,gBAAY,MAAM,WAAW,IAAI,MAAM,MAAM;AAAA,EAC/C;AAEA,QAAM,YACJ,YAAY,SAAS,IAAI,YAAY,KAAK,eAAe,IAAI;AAE/D,SAAO,EAAE,GAAG,OAAO,UAAU,WAAW,UAAU;AACpD;AAWA,SAAS,WACP,MACA,SACgC;AAChC,MAAI,uBAAuB,IAAI,GAAG;AAChC,WAAO,YAAY,MAAM,OAAO;AAAA,EAClC;AACA,MAAI,2BAA2B,IAAI,GAAG;AACpC,WAAO,gBAAgB,MAAM,OAAO;AAAA,EACtC;AACA,SAAO;AACT;AAYO,SAAS,6BACd,MACA,SACoB;AACpB,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,MAAM,OAAO;AAClC;AAWO,SAAS,4BACd,MACA,SACQ;AACR,QAAM,UAAU,6BAA6B,MAAM,OAAO;AAG1D,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AAEA,QAAM,QAAkB,CAAC;AAGzB,MAAI,QAAQ,WAAW;AACrB,UAAM,KAAK,YAAY,QAAQ,SAAS,EAAE;AAAA,EAC5C;AACA,MAAI,QAAQ,WAAW;AACrB,UAAM,KAAK,YAAY,QAAQ,SAAS,EAAE;AAAA,EAC5C;AAEA,SAAO,MAAM,KAAK,GAAG;AACvB;",
+  "names": []
+}

package/esm/filters/filter-field/utils/conversion/lezer-tree-conversion/key/json-path.js

@@ -1,6 +1,7 @@
 import { getTextFromRange } from "../../../get-text.js";
 import { removeEscapeCharacters } from "../../escape-characters.js";
 import { updateNodeValues } from "../node-mutations.js";
+import { findSpecialCharsRanges } from "../utils/range-helpers.js";
 import { convertIdentifier } from "../value/identifier.js";
 function convertJsonPath(node, doc, parserConfig) {
   const { from, to } = node;
@@ -27,14 +28,27 @@ function convertJsonPath(node, doc, parserConfig) {
     };
     let path = "$";
     let pushToPath = false;
+    let insideJsonPathNameSelector = false;
     cursor.iterate(
       (jsonPathChildNode) => {
         const nodeName = jsonPathChildNode.name;
+        if (nodeName === "JsonPathNameSelector") {
+          insideJsonPathNameSelector = true;
+        }
         if (nodeName === "JsonPathBase") {
           const text = getTextFromRange(jsonPathChildNode, doc);
           const cleanedUpRoot = removeEscapeCharacters(
             text.slice(0, -1).replace(/^"(.*(?<=^|[^\\])(?:\\\\)*)"$/, "$1")
           );
+          const invalidRootChars = findSpecialCharsRanges(cleanedUpRoot, from, [
+            "[",
+            "]",
+            "*",
+            "$"
+          ]);
+          if (invalidRootChars.length > 0) {
+            isValidJsonPath = false;
+          }
           convertedNode.root = cleanedUpRoot;
           return;
         }
@@ -45,6 +59,12 @@ function convertJsonPath(node, doc, parserConfig) {
           const text = getTextFromRange(jsonPathChildNode, doc);
           switch (nodeName) {
             case "JsonPathIdentifier":
+              if (insideJsonPathNameSelector) {
+                isValidJsonPath = false;
+              }
+              if (findSpecialCharsRanges(text, jsonPathChildNode.from, ["$", "*"]).length > 0) {
+                isValidJsonPath = false;
+              }
               path += `.${text}`;
               break;
             case "JsonPathArray":
@@ -55,6 +75,9 @@ function convertJsonPath(node, doc, parserConfig) {
               break;
           }
         }
+        if (nodeName === "PositionOperator" || nodeName === "InvalidPositionOperator") {
+          isValidJsonPath = false;
+        }
         if (nodeName === "\u26A0") {
           isValidJsonPath = false;
         }
@@ -63,6 +86,9 @@ function convertJsonPath(node, doc, parserConfig) {
         if (node2.name === "JsonPathBase") {
           pushToPath = true;
         }
+        if (node2.name === "JsonPathNameSelector") {
+          insideJsonPathNameSelector = false;
+        }
       }
     );
     convertedNode.path = path;

package/esm/filters/filter-field/utils/conversion/lezer-tree-conversion/key/json-path.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../../src/filters/filter-field/utils/conversion/lezer-tree-conversion/key/json-path.ts"],
-  "sourcesContent": ["import type { SyntaxNodeRef } from '@lezer/common';\n\nimport type { FilterFieldProps } from '../../../../FilterField.types.js';\nimport type { ConvertedLezerNode } from '../../../../types/conversion-utils.js';\nimport type {\n  FilterFieldErrorNode,\n  FilterFieldJSONPathNode,\n} from '../../../../types/tree-nodes.js';\nimport { getTextFromRange } from '../../../get-text.js';\nimport { removeEscapeCharacters } from '../../escape-characters.js';\nimport { updateNodeValues } from '../node-mutations.js';\nimport { convertIdentifier } from '../value/identifier.js';\n\n/**\n * Convert a jsonpath node.\n * @internal\n */\nexport function convertJsonPath(\n  node: SyntaxNodeRef,\n  doc: string,\n  parserConfig?: FilterFieldProps['parserConfig'],\n): ConvertedLezerNode<FilterFieldErrorNode | FilterFieldJSONPathNode> {\n  const { from, to } = node;\n  const cursor = node.node.cursor();\n\n  let convertedNode: FilterFieldErrorNode | FilterFieldJSONPathNode = {\n    type: 'Error',\n    range: {\n      from,\n      to,\n    },\n    textValue: '',\n    value: '',\n  };\n  const errors: { range: { from: number; to: number }; message: string }[] = [];\n\n  const {\n    convertedNode: { textValue, value },\n  } = convertIdentifier(node, doc);\n\n  // For JSONPath, both textValue and value are the same to be able to correctly\n  // convert it in the tree to string conversion.\n  updateNodeValues(convertedNode, textValue, textValue);\n  let isValidJsonPath = true;\n\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (parserConfig?.jsonPathConversion) {\n    convertedNode = {\n      ...convertedNode,\n      type: 'JSONPath',\n    } as FilterFieldJSONPathNode;\n\n    let path = '$';\n    let pushToPath = false;\n\n    cursor.iterate(\n      (jsonPathChildNode) => {\n        const nodeName = jsonPathChildNode.name;\n\n        if (nodeName === 'JsonPathBase') {\n          const text = getTextFromRange(jsonPathChildNode, doc);\n          // Remove trailing $ and all escape characters.\n          const cleanedUpRoot = removeEscapeCharacters(\n            text\n              .slice(0, -1) // Remove leading and trailing doublequote if it is not escaped.\n              // Properly escaped backslashes are preserved with the capturing group and the backreference.\n              .replace(/^\"(.*(?<=^|[^\\\\])(?:\\\\\\\\)*)\"$/, '$1'),\n          );\n\n          (convertedNode as FilterFieldJSONPathNode).root = cleanedUpRoot;\n          return;\n        }\n\n        if (!pushToPath) {\n          return;\n        }\n\n        if (\n          nodeName === 'JsonPathIdentifier' ||\n          nodeName === 'JsonPathArray' ||\n          nodeName === 'String' ||\n          nodeName === 'JsonPathNameSelector'\n        ) {\n          const text = getTextFromRange(jsonPathChildNode, doc);\n\n          // add the current node to the path based on its type\n          // to create a valid JSONPath\n          switch (nodeName) {\n            case 'JsonPathIdentifier':\n              path += `.${text}`;\n              break;\n            case 'JsonPathArray':\n              path += `${text}`;\n              break;\n            case 'String':\n              path += `[${text}]`;\n              break;\n          }\n        }\n\n        // An error node may occur here if the JSONPath is invalid (e.g. a$.[0]).\n        if (nodeName === '\u26A0') {\n          isValidJsonPath = false;\n        }\n      },\n      (node) => {\n        if (node.name === 'JsonPathBase') {\n          pushToPath = true;\n        }\n      },\n    );\n\n    convertedNode.path = path;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (!parserConfig?.jsonPathConversion || !isValidJsonPath) {\n    convertedNode = {\n      type: 'Error',\n      range: convertedNode.range,\n      value,\n      textValue,\n    };\n    errors.push({ range: { from, to }, message: 'invalidKey' });\n  }\n\n  return { convertedNode, errors };\n}\n"],
-  "mappings": "AAQA,SAAS,wBAAwB;AACjC,SAAS,8BAA8B;AACvC,SAAS,wBAAwB;AACjC,SAAS,yBAAyB;AAM3B,SAAS,gBACd,MACA,KACA,cACoE;AACpE,QAAM,EAAE,MAAM,GAAG,IAAI;AACrB,QAAM,SAAS,KAAK,KAAK,OAAO;AAEhC,MAAI,gBAAgE;AAAA,IAClE,MAAM;AAAA,IACN,OAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,IACA,WAAW;AAAA,IACX,OAAO;AAAA,EACT;AACA,QAAM,SAAqE,CAAC;AAE5E,QAAM;AAAA,IACJ,eAAe,EAAE,WAAW,MAAM;AAAA,EACpC,IAAI,kBAAkB,MAAM,GAAG;AAI/B,mBAAiB,eAAe,WAAW,SAAS;AACpD,MAAI,kBAAkB;AAGtB,MAAI,cAAc,oBAAoB;AACpC,oBAAgB;AAAA,MACd,GAAG;AAAA,MACH,MAAM;AAAA,IACR;AAEA,QAAI,OAAO;AACX,QAAI,aAAa;AAEjB,WAAO;AAAA,MACL,CAAC,sBAAsB;AACrB,cAAM,WAAW,kBAAkB;AAEnC,YAAI,aAAa,gBAAgB;AAC/B,gBAAM,OAAO,iBAAiB,mBAAmB,GAAG;AAEpD,gBAAM,gBAAgB;AAAA,YACpB,KACG,MAAM,GAAG,EAAE,EAEX,QAAQ,iCAAiC,IAAI;AAAA,UAClD;AAEA,UAAC,cAA0C,OAAO;AAClD;AAAA,QACF;AAEA,YAAI,CAAC,YAAY;AACf;AAAA,QACF;AAEA,YACE,aAAa,wBACb,aAAa,mBACb,aAAa,YACb,aAAa,wBACb;AACA,gBAAM,OAAO,iBAAiB,mBAAmB,GAAG;AAIpD,kBAAQ,UAAU;AAAA,YAChB,KAAK;AACH,sBAAQ,IAAI,IAAI;AAChB;AAAA,YACF,KAAK;AACH,sBAAQ,GAAG,IAAI;AACf;AAAA,YACF,KAAK;AACH,sBAAQ,IAAI,IAAI;AAChB;AAAA,UACJ;AAAA,QACF;AAGA,YAAI,aAAa,UAAK;AACpB,4BAAkB;AAAA,QACpB;AAAA,MACF;AAAA,MACA,CAACA,UAAS;AACR,YAAIA,MAAK,SAAS,gBAAgB;AAChC,uBAAa;AAAA,QACf;AAAA,MACF;AAAA,IACF;AAEA,kBAAc,OAAO;AAAA,EACvB;AAGA,MAAI,CAAC,cAAc,sBAAsB,CAAC,iBAAiB;AACzD,oBAAgB;AAAA,MACd,MAAM;AAAA,MACN,OAAO,cAAc;AAAA,MACrB;AAAA,MACA;AAAA,IACF;AACA,WAAO,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,SAAS,aAAa,CAAC;AAAA,EAC5D;AAEA,SAAO,EAAE,eAAe,OAAO;AACjC;",
+  "sourcesContent": ["import type { SyntaxNodeRef } from '@lezer/common';\n\nimport type { FilterFieldProps } from '../../../../FilterField.types.js';\nimport type { ConvertedLezerNode } from '../../../../types/conversion-utils.js';\nimport type {\n  FilterFieldErrorNode,\n  FilterFieldJSONPathNode,\n} from '../../../../types/tree-nodes.js';\nimport { getTextFromRange } from '../../../get-text.js';\nimport { removeEscapeCharacters } from '../../escape-characters.js';\nimport { updateNodeValues } from '../node-mutations.js';\nimport { findSpecialCharsRanges } from '../utils/range-helpers.js';\nimport { convertIdentifier } from '../value/identifier.js';\n\n/**\n * Convert a jsonpath node.\n * @internal\n */\nexport function convertJsonPath(\n  node: SyntaxNodeRef,\n  doc: string,\n  parserConfig?: FilterFieldProps['parserConfig'],\n): ConvertedLezerNode<FilterFieldErrorNode | FilterFieldJSONPathNode> {\n  const { from, to } = node;\n  const cursor = node.node.cursor();\n\n  let convertedNode: FilterFieldErrorNode | FilterFieldJSONPathNode = {\n    type: 'Error',\n    range: {\n      from,\n      to,\n    },\n    textValue: '',\n    value: '',\n  };\n  const errors: { range: { from: number; to: number }; message: string }[] = [];\n\n  const {\n    convertedNode: { textValue, value },\n  } = convertIdentifier(node, doc);\n\n  // For JSONPath, both textValue and value are the same to be able to correctly\n  // convert it in the tree to string conversion.\n  updateNodeValues(convertedNode, textValue, textValue);\n  let isValidJsonPath = true;\n\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (parserConfig?.jsonPathConversion) {\n    convertedNode = {\n      ...convertedNode,\n      type: 'JSONPath',\n    } as FilterFieldJSONPathNode;\n\n    let path = '$';\n    let pushToPath = false;\n    let insideJsonPathNameSelector = false;\n\n    cursor.iterate(\n      (jsonPathChildNode) => {\n        const nodeName = jsonPathChildNode.name;\n\n        if (nodeName === 'JsonPathNameSelector') {\n          insideJsonPathNameSelector = true;\n        }\n\n        if (nodeName === 'JsonPathBase') {\n          const text = getTextFromRange(jsonPathChildNode, doc);\n          // Remove trailing $ and all escape characters.\n          const cleanedUpRoot = removeEscapeCharacters(\n            text\n              .slice(0, -1) // Remove leading and trailing doublequote if it is not escaped.\n              // Properly escaped backslashes are preserved with the capturing group and the backreference.\n              .replace(/^\"(.*(?<=^|[^\\\\])(?:\\\\\\\\)*)\"$/, '$1'),\n          );\n\n          // `[`, `]`, `*` and `$` are consumed by the tokenizer but not valid in a root name.\n          const invalidRootChars = findSpecialCharsRanges(cleanedUpRoot, from, [\n            '[',\n            ']',\n            '*',\n            '$',\n          ]);\n          if (invalidRootChars.length > 0) {\n            isValidJsonPath = false;\n          }\n\n          (convertedNode as FilterFieldJSONPathNode).root = cleanedUpRoot;\n          return;\n        }\n\n        if (!pushToPath) {\n          return;\n        }\n\n        if (\n          nodeName === 'JsonPathIdentifier' ||\n          nodeName === 'JsonPathArray' ||\n          nodeName === 'String' ||\n          nodeName === 'JsonPathNameSelector'\n        ) {\n          const text = getTextFromRange(jsonPathChildNode, doc);\n\n          // add the current node to the path based on its type\n          // to create a valid JSONPath\n          switch (nodeName) {\n            case 'JsonPathIdentifier':\n              // Bracket selectors only allow a string or number, not a bare identifier.\n              if (insideJsonPathNameSelector) {\n                isValidJsonPath = false;\n              }\n\n              // `$` and `*` are not valid inside a segment.\n              if (\n                findSpecialCharsRanges(text, jsonPathChildNode.from, ['$', '*'])\n                  .length > 0\n              ) {\n                isValidJsonPath = false;\n              }\n\n              path += `.${text}`;\n              break;\n            case 'JsonPathArray':\n              path += `${text}`;\n              break;\n            case 'String':\n              path += `[${text}]`;\n              break;\n          }\n        }\n\n        if (\n          nodeName === 'PositionOperator' ||\n          nodeName === 'InvalidPositionOperator'\n        ) {\n          isValidJsonPath = false;\n        }\n\n        // An error node may occur here if the JSONPath is invalid (e.g. a$.[0]).\n        if (nodeName === '\u26A0') {\n          isValidJsonPath = false;\n        }\n      },\n      (node) => {\n        if (node.name === 'JsonPathBase') {\n          pushToPath = true;\n        }\n        if (node.name === 'JsonPathNameSelector') {\n          insideJsonPathNameSelector = false;\n        }\n      },\n    );\n\n    convertedNode.path = path;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (!parserConfig?.jsonPathConversion || !isValidJsonPath) {\n    convertedNode = {\n      type: 'Error',\n      range: convertedNode.range,\n      value,\n      textValue,\n    };\n    errors.push({ range: { from, to }, message: 'invalidKey' });\n  }\n\n  return { convertedNode, errors };\n}\n"],
+  "mappings": "AAQA,SAAS,wBAAwB;AACjC,SAAS,8BAA8B;AACvC,SAAS,wBAAwB;AACjC,SAAS,8BAA8B;AACvC,SAAS,yBAAyB;AAM3B,SAAS,gBACd,MACA,KACA,cACoE;AACpE,QAAM,EAAE,MAAM,GAAG,IAAI;AACrB,QAAM,SAAS,KAAK,KAAK,OAAO;AAEhC,MAAI,gBAAgE;AAAA,IAClE,MAAM;AAAA,IACN,OAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,IACA,WAAW;AAAA,IACX,OAAO;AAAA,EACT;AACA,QAAM,SAAqE,CAAC;AAE5E,QAAM;AAAA,IACJ,eAAe,EAAE,WAAW,MAAM;AAAA,EACpC,IAAI,kBAAkB,MAAM,GAAG;AAI/B,mBAAiB,eAAe,WAAW,SAAS;AACpD,MAAI,kBAAkB;AAGtB,MAAI,cAAc,oBAAoB;AACpC,oBAAgB;AAAA,MACd,GAAG;AAAA,MACH,MAAM;AAAA,IACR;AAEA,QAAI,OAAO;AACX,QAAI,aAAa;AACjB,QAAI,6BAA6B;AAEjC,WAAO;AAAA,MACL,CAAC,sBAAsB;AACrB,cAAM,WAAW,kBAAkB;AAEnC,YAAI,aAAa,wBAAwB;AACvC,uCAA6B;AAAA,QAC/B;AAEA,YAAI,aAAa,gBAAgB;AAC/B,gBAAM,OAAO,iBAAiB,mBAAmB,GAAG;AAEpD,gBAAM,gBAAgB;AAAA,YACpB,KACG,MAAM,GAAG,EAAE,EAEX,QAAQ,iCAAiC,IAAI;AAAA,UAClD;AAGA,gBAAM,mBAAmB,uBAAuB,eAAe,MAAM;AAAA,YACnE;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UACF,CAAC;AACD,cAAI,iBAAiB,SAAS,GAAG;AAC/B,8BAAkB;AAAA,UACpB;AAEA,UAAC,cAA0C,OAAO;AAClD;AAAA,QACF;AAEA,YAAI,CAAC,YAAY;AACf;AAAA,QACF;AAEA,YACE,aAAa,wBACb,aAAa,mBACb,aAAa,YACb,aAAa,wBACb;AACA,gBAAM,OAAO,iBAAiB,mBAAmB,GAAG;AAIpD,kBAAQ,UAAU;AAAA,YAChB,KAAK;AAEH,kBAAI,4BAA4B;AAC9B,kCAAkB;AAAA,cACpB;AAGA,kBACE,uBAAuB,MAAM,kBAAkB,MAAM,CAAC,KAAK,GAAG,CAAC,EAC5D,SAAS,GACZ;AACA,kCAAkB;AAAA,cACpB;AAEA,sBAAQ,IAAI,IAAI;AAChB;AAAA,YACF,KAAK;AACH,sBAAQ,GAAG,IAAI;AACf;AAAA,YACF,KAAK;AACH,sBAAQ,IAAI,IAAI;AAChB;AAAA,UACJ;AAAA,QACF;AAEA,YACE,aAAa,sBACb,aAAa,2BACb;AACA,4BAAkB;AAAA,QACpB;AAGA,YAAI,aAAa,UAAK;AACpB,4BAAkB;AAAA,QACpB;AAAA,MACF;AAAA,MACA,CAACA,UAAS;AACR,YAAIA,MAAK,SAAS,gBAAgB;AAChC,uBAAa;AAAA,QACf;AACA,YAAIA,MAAK,SAAS,wBAAwB;AACxC,uCAA6B;AAAA,QAC/B;AAAA,MACF;AAAA,IACF;AAEA,kBAAc,OAAO;AAAA,EACvB;AAGA,MAAI,CAAC,cAAc,sBAAsB,CAAC,iBAAiB;AACzD,oBAAgB;AAAA,MACd,MAAM;AAAA,MACN,OAAO,cAAc;AAAA,MACrB;AAAA,MACA;AAAA,IACF;AACA,WAAO,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,SAAS,aAAa,CAAC;AAAA,EAC5D;AAEA,SAAO,EAAE,eAAe,OAAO;AACjC;",
   "names": ["node"]
 }