@dynatrace/strato-components 3.5.2 → 3.7.0

package/esm/filters/filter-field/utils/value-operations/add-filter.js

@@ -0,0 +1,209 @@
+import {
+  DURATION_REGEX,
+  VARIABLE_REGEX,
+  findIdenticalStatement,
+  findSearchStatement,
+  leafEquals,
+  mapInputOperator,
+  statementPolarity
+} from "./value-operation-utils.js";
+import { getNumberParser } from "../../parser/getNumberParser.js";
+import { convertStringToFilterFieldTree } from "../conversion/string-tree-conversion.js";
+import { convertFilterFieldTreeToString } from "../conversion/tree-string-conversion.js";
+import {
+  isFilterFieldGroupNode,
+  isFilterFieldListNode,
+  isFilterFieldStatementNode
+} from "../tree-node-guards.js";
+import { FILTERFIELD_ALL_OPERATORS } from "../validation-utils/operator-specification.js";
+import {
+  isValidIPAddress,
+  isValidSmartscapeId,
+  isValidTimestamp,
+  isValidUID
+} from "../validation-utils/type-validators.js";
+function addFilter(currentValue, filter, options) {
+  const parserConfig = {
+    searchConversion: true,
+    ...options?.parserConfig
+  };
+  const { tree } = convertStringToFilterFieldTree(currentValue, {
+    validatorMap: { comparisonOperators: FILTERFIELD_ALL_OPERATORS },
+    // Always recognize search statements when scanning the existing value, regardless
+    // of the caller's parserConfig. The caller's config only affects new node construction.
+    parserConfig: { ...parserConfig, searchConversion: true }
+  });
+  const rootGroup = prepareRoot(tree);
+  const operator = mapInputOperator(filter.comparisonOperator);
+  if (operator.node.type === "SearchOperator" && filter.value !== void 0 && findSearchStatement(rootGroup, filter.value) !== void 0) {
+    return { updatedStatement: false, value: currentValue };
+  }
+  const match = operator.polarity === "none" || filter.key === void 0 ? void 0 : findRightmostMatchingStatement(
+    rootGroup,
+    filter.key,
+    operator.polarity
+  );
+  if (match) {
+    const inputValue = filter.value;
+    const existingValue = match.value;
+    if (isFilterFieldListNode(existingValue) && inputValue !== void 0) {
+      const list = existingValue;
+      if (list.value.some((leaf) => leafEquals(leaf, inputValue))) {
+        return { updatedStatement: false, value: currentValue };
+      }
+      list.value.push(makeLeaf(inputValue, parserConfig));
+      return {
+        updatedStatement: true,
+        value: convertFilterFieldTreeToString(rootGroup)
+      };
+    }
+    if (existingValue && !isFilterFieldListNode(existingValue) && existingValue.type !== "Error" && inputValue !== void 0) {
+      const existingLeaf = existingValue;
+      const valuesEqual = leafEquals(existingLeaf, inputValue);
+      const inputIsInclusion = operator.node.type === "InclusionOperator";
+      if (valuesEqual && !inputIsInclusion) {
+        return { updatedStatement: false, value: currentValue };
+      }
+      const promotionList = {
+        type: "List",
+        value: valuesEqual ? [existingLeaf] : [existingLeaf, makeLeaf(inputValue, parserConfig)]
+      };
+      match.comparisonOperator = {
+        type: "InclusionOperator",
+        value: operator.polarity === "positive" ? "in" : "not in"
+      };
+      match.value = promotionList;
+      return {
+        updatedStatement: true,
+        value: convertFilterFieldTreeToString(rootGroup)
+      };
+    }
+  }
+  if (operator.polarity === "none" && filter.key !== void 0 && findIdenticalStatement(
+    rootGroup,
+    filter.key,
+    operator.node,
+    filter.value
+  ) !== void 0) {
+    return { updatedStatement: false, value: currentValue };
+  }
+  appendStatement(rootGroup, createStatement(filter, operator, parserConfig));
+  return {
+    updatedStatement: true,
+    value: convertFilterFieldTreeToString(rootGroup)
+  };
+}
+function prepareRoot(tree) {
+  if (!tree) {
+    return {
+      type: "Group",
+      logicalOperator: "AND",
+      explicit: false,
+      explicitLogicalOperator: false,
+      children: []
+    };
+  }
+  if (tree.explicit || tree.logicalOperator === "OR") {
+    return {
+      type: "Group",
+      logicalOperator: "AND",
+      explicit: false,
+      explicitLogicalOperator: false,
+      children: [{ ...tree, explicit: true }]
+    };
+  }
+  return tree;
+}
+function appendStatement(group, statement) {
+  const previousSibling = group.children.at(-1);
+  group.children.push(statement);
+  if (previousSibling && isFilterFieldGroupNode(previousSibling) && group.children.length === 2) {
+    group.explicitLogicalOperator = true;
+  }
+}
+function createStatement(filter, operator, parserConfig) {
+  const statement = {
+    type: "Statement",
+    comparisonOperator: operator.node
+  };
+  if (filter.key !== void 0) {
+    statement.key = createKey(filter.key, parserConfig);
+  }
+  if (filter.value !== void 0) {
+    const leaf = makeLeaf(filter.value, parserConfig);
+    statement.value = operator.node.type === "InclusionOperator" ? { type: "List", value: [leaf] } : leaf;
+  }
+  return statement;
+}
+function findRightmostMatchingStatement(group, key, polarity) {
+  for (let i = group.children.length - 1; i >= 0; i--) {
+    const child = group.children[i];
+    if (isFilterFieldGroupNode(child)) {
+      const nested = findRightmostMatchingStatement(child, key, polarity);
+      if (nested) {
+        return nested;
+      }
+    } else if (isFilterFieldStatementNode(child)) {
+      const childKey = child.key;
+      if (childKey && (childKey.type === "Key" || childKey.type === "JSONPath") && childKey.value === key && statementPolarity(child) === polarity) {
+        return child;
+      }
+    }
+  }
+  return void 0;
+}
+function makeLeaf(value, parserConfig) {
+  if (typeof value === "number") {
+    return { type: "Number", value };
+  }
+  if (typeof value === "boolean") {
+    return { type: "Boolean", value };
+  }
+  const durationMatch = DURATION_REGEX.exec(value);
+  if (durationMatch) {
+    return {
+      type: "Duration",
+      value: parseInt(durationMatch[1], 10),
+      unit: durationMatch[2].toLowerCase()
+    };
+  }
+  if (value === "true" || value === "false") {
+    return { type: "Boolean", value: value === "true" };
+  }
+  const parsedNumber = getNumberParser().parse(value);
+  if (!isNaN(parsedNumber)) {
+    return { type: "Number", value: parsedNumber };
+  }
+  if (VARIABLE_REGEX.test(value)) {
+    return { type: "Variable", value, variableType: "Any" };
+  }
+  if (parserConfig?.ipAddressConversion && isValidIPAddress(value)) {
+    return { type: "IPAddress", value, textValue: value };
+  }
+  if (parserConfig?.timestampConversion && isValidTimestamp(value)) {
+    return { type: "Timestamp", value, textValue: value };
+  }
+  if (parserConfig?.uidConversion && isValidUID(value)) {
+    return { type: "UID", value, textValue: value };
+  }
+  if (parserConfig?.smartscapeIdConversion && isValidSmartscapeId(value)) {
+    return { type: "SmartscapeId", value, textValue: value };
+  }
+  return { type: "String", value };
+}
+function createKey(keyString, parserConfig) {
+  if (parserConfig?.jsonPathConversion && keyString.includes("$")) {
+    const { tree } = convertStringToFilterFieldTree(`${keyString} = x`, {
+      parserConfig
+    });
+    const statement = tree?.children.find(isFilterFieldStatementNode);
+    if (statement?.key?.type === "JSONPath") {
+      return statement.key;
+    }
+  }
+  return { type: "Key", value: keyString };
+}
+export {
+  addFilter
+};
+//# sourceMappingURL=add-filter.js.map

package/esm/filters/filter-field/utils/value-operations/add-filter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/filters/filter-field/utils/value-operations/add-filter.ts"],
+  "sourcesContent": ["import {\n  DURATION_REGEX,\n  VARIABLE_REGEX,\n  findIdenticalStatement,\n  findSearchStatement,\n  leafEquals,\n  mapInputOperator,\n  statementPolarity,\n  type OperatorDescriptor,\n} from './value-operation-utils.js';\nimport type { FilterFieldProps } from '../../FilterField.types.js';\nimport { getNumberParser } from '../../parser/getNumberParser.js';\nimport type {\n  SimpleFilterFieldBooleanNode,\n  SimpleFilterFieldDurationNode,\n  SimpleFilterFieldGroupNode,\n  SimpleFilterFieldIPAddressNode,\n  SimpleFilterFieldInclusionOperatorNode,\n  SimpleFilterFieldJSONPathNode,\n  SimpleFilterFieldKeyNode,\n  SimpleFilterFieldLeafNode,\n  SimpleFilterFieldListNode,\n  SimpleFilterFieldNode,\n  SimpleFilterFieldNumberNode,\n  SimpleFilterFieldSmartscapeIdNode,\n  SimpleFilterFieldStatementNode,\n  SimpleFilterFieldStringNode,\n  SimpleFilterFieldTimestampNode,\n  SimpleFilterFieldTree,\n  SimpleFilterFieldUIDNode,\n  SimpleFilterFieldVariableNode,\n} from '../../types/conversion-tree-nodes.js';\nimport type {\n  FilterFieldValueOperationResult,\n  FilterFieldValueOperationStatement,\n} from '../../types/value-operations.js';\nimport { convertStringToFilterFieldTree } from '../conversion/string-tree-conversion.js';\nimport { convertFilterFieldTreeToString } from '../conversion/tree-string-conversion.js';\nimport {\n  isFilterFieldGroupNode,\n  isFilterFieldListNode,\n  isFilterFieldStatementNode,\n} from '../tree-node-guards.js';\nimport { FILTERFIELD_ALL_OPERATORS } from '../validation-utils/operator-specification.js';\nimport {\n  isValidIPAddress,\n  isValidSmartscapeId,\n  isValidTimestamp,\n  isValidUID,\n} from '../validation-utils/type-validators.js';\n\n/**\n * Adds a filter statement or value to an existing FilterField value string.\n *\n * - If no statement with the given key exists, a new one is appended at the end.\n * - If a matching `key = value` statement exists, it is converted to `key in (existingValue, newValue)`.\n * - If a matching `key in (...)` statement exists, the new value is appended to the list.\n * - The same merge logic applies to `!=` / `not in`.\n * - When multiple statements with the same key exist, the rightmost one (in document order) wins.\n *\n * @public\n * @param currentValue - The current FilterField value string.\n * @param filter - The filter statement or value to add.\n * @param options - Optional configuration. `parserConfig` controls how `currentValue` is parsed\n *                  and which leaf types are constructed for new keys / values.\n * @returns The new FilterField value string and whether the operation produced a change.\n */\nexport function addFilter(\n  currentValue: string,\n  filter: FilterFieldValueOperationStatement,\n  options?: {\n    /** Parser config to apply when interpreting the existing value and constructing new nodes. */\n    parserConfig?: FilterFieldProps['parserConfig'];\n  },\n): FilterFieldValueOperationResult {\n  const parserConfig: FilterFieldProps['parserConfig'] = {\n    searchConversion: true,\n    ...options?.parserConfig,\n  };\n  const { tree } = convertStringToFilterFieldTree(currentValue, {\n    validatorMap: { comparisonOperators: FILTERFIELD_ALL_OPERATORS },\n    // Always recognize search statements when scanning the existing value, regardless\n    // of the caller's parserConfig. The caller's config only affects new node construction.\n    parserConfig: { ...parserConfig, searchConversion: true },\n  });\n  const rootGroup = prepareRoot(tree);\n\n  const operator = mapInputOperator(filter.comparisonOperator);\n\n  if (\n    operator.node.type === 'SearchOperator' &&\n    filter.value !== undefined &&\n    findSearchStatement(rootGroup, filter.value) !== undefined\n  ) {\n    return { updatedStatement: false, value: currentValue };\n  }\n\n  const match =\n    operator.polarity === 'none' || filter.key === undefined\n      ? undefined\n      : findRightmostMatchingStatement(\n          rootGroup,\n          filter.key,\n          operator.polarity,\n        );\n\n  if (match) {\n    const inputValue = filter.value;\n    const existingValue = match.value;\n\n    // Case 1: existing statement is already a list \u2014 `key in (...)` or `key not in (...)`.\n    // Append the new value, or deduplicate if it's already present.\n    if (isFilterFieldListNode(existingValue) && inputValue !== undefined) {\n      const list = existingValue as SimpleFilterFieldListNode;\n      if (list.value.some((leaf) => leafEquals(leaf, inputValue))) {\n        return { updatedStatement: false, value: currentValue };\n      }\n      list.value.push(makeLeaf(inputValue, parserConfig));\n      return {\n        updatedStatement: true,\n        value: convertFilterFieldTreeToString(rootGroup),\n      };\n    }\n\n    // Case 2: existing statement has a single leaf \u2014 `key = X` or `key != X`.\n    // Promote to a list, or deduplicate if the value is already present and the\n    // caller did not explicitly request the list form via `in` / `not in`.\n    if (\n      existingValue &&\n      !isFilterFieldListNode(existingValue) &&\n      existingValue.type !== 'Error' &&\n      inputValue !== undefined\n    ) {\n      const existingLeaf = existingValue as SimpleFilterFieldLeafNode;\n      const valuesEqual = leafEquals(existingLeaf, inputValue);\n      const inputIsInclusion = operator.node.type === 'InclusionOperator';\n\n      // Skip when the input operator matches the existing one and the value\n      // is already present. When the input operator is `in` / `not in` the\n      // caller has explicitly asked for the list form, so promote even if the\n      // value would be a duplicate \u2014 the resulting list keeps just that value.\n      if (valuesEqual && !inputIsInclusion) {\n        return { updatedStatement: false, value: currentValue };\n      }\n\n      // Promote `key = X` \u2192 `key in (X, new)` (or `key in (X)` when deduplicating with inclusion).\n      const promotionList: SimpleFilterFieldListNode = {\n        type: 'List',\n        value: valuesEqual\n          ? [existingLeaf]\n          : [existingLeaf, makeLeaf(inputValue, parserConfig)],\n      };\n      match.comparisonOperator = {\n        type: 'InclusionOperator',\n        value: operator.polarity === 'positive' ? 'in' : 'not in',\n      } as SimpleFilterFieldInclusionOperatorNode;\n      match.value = promotionList;\n      return {\n        updatedStatement: true,\n        value: convertFilterFieldTreeToString(rootGroup),\n      };\n    }\n  }\n\n  // For non-merging operators (polarity 'none'), still deduplicate exact-match statements.\n  // Search deduplicate is handled above; merging-polarity deduplicate is handled via `match`.\n  if (\n    operator.polarity === 'none' &&\n    filter.key !== undefined &&\n    findIdenticalStatement(\n      rootGroup,\n      filter.key,\n      operator.node,\n      filter.value,\n    ) !== undefined\n  ) {\n    return { updatedStatement: false, value: currentValue };\n  }\n\n  appendStatement(rootGroup, createStatement(filter, operator, parserConfig));\n  return {\n    updatedStatement: true,\n    value: convertFilterFieldTreeToString(rootGroup),\n  };\n}\n\nfunction prepareRoot(tree: SimpleFilterFieldTree): SimpleFilterFieldGroupNode {\n  if (!tree) {\n    return {\n      type: 'Group',\n      logicalOperator: 'AND',\n      explicit: false,\n      explicitLogicalOperator: false,\n      children: [],\n    };\n  }\n  if (tree.explicit || tree.logicalOperator === 'OR') {\n    return {\n      type: 'Group',\n      logicalOperator: 'AND',\n      explicit: false,\n      explicitLogicalOperator: false,\n      children: [{ ...tree, explicit: true }],\n    };\n  }\n  return tree;\n}\n\nfunction appendStatement(\n  group: SimpleFilterFieldGroupNode,\n  statement: SimpleFilterFieldStatementNode,\n): void {\n  const previousSibling = group.children.at(-1);\n  group.children.push(statement);\n  // Only make the logical operator explicit when the previous sibling is a group\n  // AND the group had exactly one child before this push (length is now 2).\n  // Setting explicitLogicalOperator on the root affects the separator between ALL\n  // children, so we must not set it retroactively when the root already had multiple\n  // children with their own implicit separators.\n  if (\n    previousSibling &&\n    isFilterFieldGroupNode(previousSibling) &&\n    group.children.length === 2\n  ) {\n    group.explicitLogicalOperator = true;\n  }\n}\n\nfunction createStatement(\n  filter: FilterFieldValueOperationStatement,\n  operator: OperatorDescriptor,\n  parserConfig: FilterFieldProps['parserConfig'],\n): SimpleFilterFieldStatementNode {\n  const statement: SimpleFilterFieldStatementNode = {\n    type: 'Statement',\n    comparisonOperator: operator.node,\n  };\n  if (filter.key !== undefined) {\n    statement.key = createKey(filter.key, parserConfig);\n  }\n  if (filter.value !== undefined) {\n    const leaf = makeLeaf(filter.value, parserConfig);\n    statement.value =\n      operator.node.type === 'InclusionOperator'\n        ? { type: 'List', value: [leaf] }\n        : leaf;\n  }\n  return statement;\n}\n\nfunction findRightmostMatchingStatement(\n  group: SimpleFilterFieldGroupNode,\n  key: string,\n  polarity: 'positive' | 'negative',\n): SimpleFilterFieldStatementNode | undefined {\n  for (let i = group.children.length - 1; i >= 0; i--) {\n    const child: SimpleFilterFieldNode = group.children[i];\n    if (isFilterFieldGroupNode(child)) {\n      const nested = findRightmostMatchingStatement(child, key, polarity);\n      if (nested) {\n        return nested;\n      }\n    } else if (isFilterFieldStatementNode(child)) {\n      const childKey = child.key;\n      if (\n        childKey &&\n        (childKey.type === 'Key' || childKey.type === 'JSONPath') &&\n        childKey.value === key &&\n        statementPolarity(child) === polarity\n      ) {\n        return child;\n      }\n    }\n  }\n  return undefined;\n}\n\nfunction makeLeaf(\n  value: string | number | boolean,\n  parserConfig: FilterFieldProps['parserConfig'],\n):\n  | SimpleFilterFieldStringNode\n  | SimpleFilterFieldNumberNode\n  | SimpleFilterFieldBooleanNode\n  | SimpleFilterFieldDurationNode\n  | SimpleFilterFieldVariableNode\n  | SimpleFilterFieldIPAddressNode\n  | SimpleFilterFieldTimestampNode\n  | SimpleFilterFieldUIDNode\n  | SimpleFilterFieldSmartscapeIdNode {\n  if (typeof value === 'number') {\n    return { type: 'Number', value };\n  }\n  if (typeof value === 'boolean') {\n    return { type: 'Boolean', value };\n  }\n\n  const durationMatch = DURATION_REGEX.exec(value);\n  if (durationMatch) {\n    return {\n      type: 'Duration',\n      value: parseInt(durationMatch[1], 10),\n      unit: durationMatch[2].toLowerCase() as SimpleFilterFieldDurationNode['unit'],\n    };\n  }\n  if (value === 'true' || value === 'false') {\n    return { type: 'Boolean', value: value === 'true' };\n  }\n  const parsedNumber = getNumberParser().parse(value);\n  if (!isNaN(parsedNumber)) {\n    return { type: 'Number', value: parsedNumber };\n  }\n  if (VARIABLE_REGEX.test(value)) {\n    return { type: 'Variable', value, variableType: 'Any' };\n  }\n\n  // Opt-in detections gated on parserConfig flags.\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (parserConfig?.ipAddressConversion && isValidIPAddress(value)) {\n    return { type: 'IPAddress', value, textValue: value };\n  }\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (parserConfig?.timestampConversion && isValidTimestamp(value)) {\n    return { type: 'Timestamp', value, textValue: value };\n  }\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (parserConfig?.uidConversion && isValidUID(value)) {\n    return { type: 'UID', value, textValue: value };\n  }\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (parserConfig?.smartscapeIdConversion && isValidSmartscapeId(value)) {\n    return { type: 'SmartscapeId', value, textValue: value };\n  }\n  return { type: 'String', value };\n}\n\nfunction createKey(\n  keyString: string,\n  parserConfig: FilterFieldProps['parserConfig'],\n): SimpleFilterFieldKeyNode | SimpleFilterFieldJSONPathNode {\n  // When the caller opts in via `jsonPathConversion`, run a synthetic parse so\n  // the lezer grammar decides whether the key is a JSONPath. Falls back to a\n  // plain `Key` when the synthetic statement doesn't produce a JSONPath.\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (parserConfig?.jsonPathConversion && keyString.includes('$')) {\n    const { tree } = convertStringToFilterFieldTree(`${keyString} = x`, {\n      parserConfig,\n    });\n    const statement = tree?.children.find(isFilterFieldStatementNode);\n    if (statement?.key?.type === 'JSONPath') {\n      return statement.key;\n    }\n  }\n  return { type: 'Key', value: keyString };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,180 @@
+import {
+  leafEquals,
+  mapInputOperator,
+  statementPolarity
+} from "./value-operation-utils.js";
+import { convertStringToFilterFieldTree } from "../conversion/string-tree-conversion.js";
+import { convertFilterFieldTreeToString } from "../conversion/tree-string-conversion.js";
+import {
+  isFilterFieldGroupNode,
+  isFilterFieldListNode,
+  isFilterFieldStatementNode
+} from "../tree-node-guards.js";
+import { FILTERFIELD_ALL_OPERATORS } from "../validation-utils/operator-specification.js";
+function removeFilter(currentValue, filter, options) {
+  const { tree } = convertStringToFilterFieldTree(currentValue, {
+    validatorMap: {
+      comparisonOperators: [...FILTERFIELD_ALL_OPERATORS]
+    },
+    parserConfig: { searchConversion: true }
+  });
+  if (!tree) {
+    return { updatedStatement: false, value: currentValue };
+  }
+  const operator = mapInputOperator(filter.comparisonOperator);
+  let updatedStatement = false;
+  if (operator.node.type === "SearchOperator") {
+    if (filter.value === void 0) {
+      return { updatedStatement: false, value: currentValue };
+    }
+    do {
+      const found = removeRightmostMatch(tree, (statement) => {
+        const statementOperator = statement.comparisonOperator;
+        const statementValue = statement.value;
+        return statementOperator?.type === "SearchOperator" && statementValue !== void 0 && !isFilterFieldListNode(statementValue) && leafEquals(
+          statementValue,
+          filter.value
+        );
+      });
+      if (!found) {
+        break;
+      }
+      updatedStatement = true;
+    } while (options?.removeAll);
+    return updatedStatement ? { updatedStatement: true, value: convertFilterFieldTreeToString(tree) } : { updatedStatement: false, value: currentValue };
+  }
+  if (filter.key === void 0) {
+    return { updatedStatement: false, value: currentValue };
+  }
+  if (operator.polarity === "none") {
+    do {
+      const found = removeRightmostMatch(tree, (statement) => {
+        const statementKey = statement.key;
+        if (!statementKey || statementKey.type !== "Key" && statementKey.type !== "JSONPath" || statementKey.value !== filter.key) {
+          return false;
+        }
+        const statementOperator = statement.comparisonOperator;
+        if (!statementOperator || statementOperator.type !== operator.node.type || statementOperator.value !== operator.node.value) {
+          return false;
+        }
+        if (operator.node.type === "ExistsOperator" || filter.value === void 0) {
+          return true;
+        }
+        const statementValue = statement.value;
+        return statementValue !== void 0 && !isFilterFieldListNode(statementValue) && statementValue.type !== "Error" && leafEquals(statementValue, filter.value);
+      });
+      if (!found) {
+        break;
+      }
+      updatedStatement = true;
+    } while (options?.removeAll);
+    return updatedStatement ? { updatedStatement: true, value: convertFilterFieldTreeToString(tree) } : { updatedStatement: false, value: currentValue };
+  }
+  do {
+    const found = removeOrMutateRightmostPolarityMatch(
+      tree,
+      filter.key,
+      operator.polarity,
+      filter.value
+    );
+    if (!found) {
+      break;
+    }
+    updatedStatement = true;
+  } while (options?.removeAll);
+  return updatedStatement ? { updatedStatement: true, value: convertFilterFieldTreeToString(tree) } : { updatedStatement: false, value: currentValue };
+}
+function removeRightmostMatch(group, predicate) {
+  for (let i = group.children.length - 1; i >= 0; i--) {
+    const child = group.children[i];
+    if (isFilterFieldGroupNode(child)) {
+      if (removeRightmostMatch(child, predicate)) {
+        if (child.children.length === 0) {
+          group.children.splice(i, 1);
+        }
+        if (group.children.length === 1) {
+          recursiveClearExplicitGroup(group);
+        }
+        return true;
+      }
+    } else if (isFilterFieldStatementNode(child) && predicate(child)) {
+      group.children.splice(i, 1);
+      if (group.children.length === 1) {
+        recursiveClearExplicitGroup(group);
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function removeOrMutateRightmostPolarityMatch(group, key, polarity, value) {
+  for (let i = group.children.length - 1; i >= 0; i--) {
+    const child = group.children[i];
+    if (isFilterFieldGroupNode(child)) {
+      if (removeOrMutateRightmostPolarityMatch(child, key, polarity, value)) {
+        if (child.children.length === 0) {
+          group.children.splice(i, 1);
+        }
+        if (group.children.length === 1) {
+          recursiveClearExplicitGroup(group);
+        }
+        return true;
+      }
+    } else if (isFilterFieldStatementNode(child)) {
+      const statementKey = child.key;
+      if (!statementKey || statementKey.type !== "Key" && statementKey.type !== "JSONPath" || statementKey.value !== key || statementPolarity(child) !== polarity) {
+        continue;
+      }
+      const statementValue = child.value;
+      if (!statementValue) {
+        continue;
+      }
+      if (isFilterFieldListNode(statementValue)) {
+        const list = statementValue;
+        const valueIndex = list.value.findIndex(
+          (leaf) => leafEquals(leaf, value)
+        );
+        if (valueIndex === -1) {
+          continue;
+        }
+        if (list.value.length === 1) {
+          group.children.splice(i, 1);
+          if (group.children.length === 1) {
+            recursiveClearExplicitGroup(group);
+          }
+        } else if (list.value.length === 2) {
+          const remaining = list.value[valueIndex === 0 ? 1 : 0];
+          const statement = child;
+          statement.comparisonOperator = {
+            type: "ComparisonOperator",
+            value: polarity === "positive" ? "=" : "!="
+          };
+          statement.value = remaining;
+        } else {
+          list.value.splice(valueIndex, 1);
+        }
+        return true;
+      } else if (statementValue.type !== "Error" && leafEquals(statementValue, value)) {
+        group.children.splice(i, 1);
+        if (group.children.length === 1) {
+          recursiveClearExplicitGroup(group);
+        }
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function recursiveClearExplicitGroup(group) {
+  group.explicit = false;
+  if (group.children.length <= 1) {
+    group.explicitLogicalOperator = false;
+  }
+  if (group.children.length === 1 && isFilterFieldGroupNode(group.children[0])) {
+    recursiveClearExplicitGroup(group.children[0]);
+  }
+}
+export {
+  removeFilter
+};
+//# sourceMappingURL=remove-filter.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/filters/filter-field/utils/value-operations/remove-filter.ts"],
+  "sourcesContent": ["import {\n  leafEquals,\n  mapInputOperator,\n  statementPolarity,\n} from './value-operation-utils.js';\nimport type {\n  SimpleFilterFieldComparisonOperatorNode,\n  SimpleFilterFieldGroupNode,\n  SimpleFilterFieldLeafNode,\n  SimpleFilterFieldListNode,\n  SimpleFilterFieldNode,\n  SimpleFilterFieldStatementNode,\n} from '../../types/conversion-tree-nodes.js';\nimport type {\n  FilterFieldValueOperationResult,\n  FilterFieldValueOperationStatement,\n} from '../../types/value-operations.js';\nimport { convertStringToFilterFieldTree } from '../conversion/string-tree-conversion.js';\nimport { convertFilterFieldTreeToString } from '../conversion/tree-string-conversion.js';\nimport {\n  isFilterFieldGroupNode,\n  isFilterFieldListNode,\n  isFilterFieldStatementNode,\n} from '../tree-node-guards.js';\nimport { FILTERFIELD_ALL_OPERATORS } from '../validation-utils/operator-specification.js';\n\n/**\n * Removes a filter statement or value from an existing FilterField value string.\n *\n * - If the value is not present for the specified key, the statement is not changed.\n * - If removing a value from `key in (v1, v2)` leaves one value, the statement collapses to `key = v1`.\n * - When multiple statements with the same key, operator and value exist, the rightmost one (in document order) is removed.\n * - When `options.removeAll` is `true`, all matching occurrences are removed instead of only the rightmost one.\n *\n * @public\n * @param currentValue - The current FilterField value string.\n * @param filter - The filter statement or value to remove.\n * @param options - Optional configuration for the remove operation.\n * @returns The new FilterField value string and whether the operation produced a change.\n */\nexport function removeFilter(\n  currentValue: string,\n  filter: FilterFieldValueOperationStatement,\n  options?: { removeAll?: boolean },\n): FilterFieldValueOperationResult {\n  // Parse with a permissive validatorMap so all operators (including !~ / ~,\n  // which are absent from the default set) are preserved as valid nodes rather\n  // than being down-converted to Error nodes by the parser.\n  const { tree } = convertStringToFilterFieldTree(currentValue, {\n    validatorMap: {\n      comparisonOperators: [...FILTERFIELD_ALL_OPERATORS],\n    },\n    parserConfig: { searchConversion: true },\n  });\n\n  if (!tree) {\n    return { updatedStatement: false, value: currentValue };\n  }\n\n  const operator = mapInputOperator(filter.comparisonOperator);\n  let updatedStatement = false;\n\n  // Search operator: find and remove a matching `* ~ value` statement.\n  if (operator.node.type === 'SearchOperator') {\n    if (filter.value === undefined) {\n      return { updatedStatement: false, value: currentValue };\n    }\n    do {\n      const found = removeRightmostMatch(tree, (statement) => {\n        const statementOperator = statement.comparisonOperator;\n        const statementValue = statement.value;\n        return (\n          statementOperator?.type === 'SearchOperator' &&\n          statementValue !== undefined &&\n          !isFilterFieldListNode(statementValue) &&\n          leafEquals(\n            statementValue as SimpleFilterFieldLeafNode,\n            filter.value as string | number | boolean,\n          )\n        );\n      });\n      if (!found) {\n        break;\n      }\n      updatedStatement = true;\n    } while (options?.removeAll);\n    return updatedStatement\n      ? { updatedStatement: true, value: convertFilterFieldTreeToString(tree) }\n      : { updatedStatement: false, value: currentValue };\n  }\n\n  if (filter.key === undefined) {\n    return { updatedStatement: false, value: currentValue };\n  }\n\n  // Polarity 'none' operators (exists, not-exists, comparison operators like <, >, \u2026):\n  // require an exact key+operator(+value) match and remove the whole statement.\n  if (operator.polarity === 'none') {\n    do {\n      const found = removeRightmostMatch(tree, (statement) => {\n        const statementKey = statement.key;\n        if (\n          !statementKey ||\n          (statementKey.type !== 'Key' && statementKey.type !== 'JSONPath') ||\n          statementKey.value !== filter.key\n        ) {\n          return false;\n        }\n        const statementOperator = statement.comparisonOperator;\n        if (\n          !statementOperator ||\n          statementOperator.type !== operator.node.type ||\n          statementOperator.value !== operator.node.value\n        ) {\n          return false;\n        }\n        if (\n          operator.node.type === 'ExistsOperator' ||\n          filter.value === undefined\n        ) {\n          return true;\n        }\n        const statementValue = statement.value;\n        return (\n          statementValue !== undefined &&\n          !isFilterFieldListNode(statementValue) &&\n          statementValue.type !== 'Error' &&\n          leafEquals(statementValue as SimpleFilterFieldLeafNode, filter.value)\n        );\n      });\n      if (!found) {\n        break;\n      }\n      updatedStatement = true;\n    } while (options?.removeAll);\n    return updatedStatement\n      ? { updatedStatement: true, value: convertFilterFieldTreeToString(tree) }\n      : { updatedStatement: false, value: currentValue };\n  }\n\n  // Polarity-based operators (equals/in or not-equals/not-in): target the\n  // rightmost statement with matching key, polarity, and containing the target value.\n  do {\n    const found = removeOrMutateRightmostPolarityMatch(\n      tree,\n      filter.key,\n      operator.polarity,\n      filter.value as string | number | boolean,\n    );\n    if (!found) {\n      break;\n    }\n    updatedStatement = true;\n  } while (options?.removeAll);\n\n  return updatedStatement\n    ? { updatedStatement: true, value: convertFilterFieldTreeToString(tree) }\n    : { updatedStatement: false, value: currentValue };\n}\n\n// Traverses the tree in reverse and removes the rightmost statement for which\n// `predicate` returns `true`. Propagates empty-group cleanup as it unwinds.\nfunction removeRightmostMatch(\n  group: SimpleFilterFieldGroupNode,\n  predicate: (statement: SimpleFilterFieldStatementNode) => boolean,\n): boolean {\n  for (let i = group.children.length - 1; i >= 0; i--) {\n    const child: SimpleFilterFieldNode = group.children[i];\n    if (isFilterFieldGroupNode(child)) {\n      if (removeRightmostMatch(child, predicate)) {\n        if (child.children.length === 0) {\n          group.children.splice(i, 1);\n        }\n        if (group.children.length === 1) {\n          recursiveClearExplicitGroup(group);\n        }\n        return true;\n      }\n    } else if (isFilterFieldStatementNode(child) && predicate(child)) {\n      group.children.splice(i, 1);\n      if (group.children.length === 1) {\n        recursiveClearExplicitGroup(group);\n      }\n      return true;\n    }\n  }\n  return false;\n}\n\n// Traverses the tree in reverse and, at the rightmost statement matching the\n// given key + polarity + value, either:\n//   - splices a value from the list (\u2265 3 elements),\n//   - downgrades a 2-element list to a single-leaf statement, or\n//   - removes the statement entirely (1-element list or plain leaf).\n// Returns true if a match was found and acted on.\nfunction removeOrMutateRightmostPolarityMatch(\n  group: SimpleFilterFieldGroupNode,\n  key: string,\n  polarity: 'positive' | 'negative',\n  value: string | number | boolean,\n): boolean {\n  for (let i = group.children.length - 1; i >= 0; i--) {\n    const child: SimpleFilterFieldNode = group.children[i];\n    if (isFilterFieldGroupNode(child)) {\n      if (removeOrMutateRightmostPolarityMatch(child, key, polarity, value)) {\n        if (child.children.length === 0) {\n          group.children.splice(i, 1);\n        }\n        if (group.children.length === 1) {\n          recursiveClearExplicitGroup(group);\n        }\n        return true;\n      }\n    } else if (isFilterFieldStatementNode(child)) {\n      const statementKey = child.key;\n      if (\n        !statementKey ||\n        (statementKey.type !== 'Key' && statementKey.type !== 'JSONPath') ||\n        statementKey.value !== key ||\n        statementPolarity(child) !== polarity\n      ) {\n        continue;\n      }\n      const statementValue = child.value;\n      if (!statementValue) {\n        continue;\n      }\n      if (isFilterFieldListNode(statementValue)) {\n        const list = statementValue as SimpleFilterFieldListNode;\n        const valueIndex = list.value.findIndex((leaf) =>\n          leafEquals(leaf, value),\n        );\n        if (valueIndex === -1) {\n          continue;\n        }\n        if (list.value.length === 1) {\n          // Only one value left \u2014 remove the whole statement.\n          group.children.splice(i, 1);\n          if (group.children.length === 1) {\n            recursiveClearExplicitGroup(group);\n          }\n        } else if (list.value.length === 2) {\n          // Downgrade `key in (a, b)` \u2192 `key = a` (the remaining value).\n          const remaining = list.value[valueIndex === 0 ? 1 : 0];\n          const statement = child as SimpleFilterFieldStatementNode;\n          statement.comparisonOperator = {\n            type: 'ComparisonOperator',\n            value: polarity === 'positive' ? '=' : '!=',\n          } as SimpleFilterFieldComparisonOperatorNode;\n          statement.value = remaining;\n        } else {\n          list.value.splice(valueIndex, 1);\n        }\n        return true;\n      } else if (\n        statementValue.type !== 'Error' &&\n        leafEquals(statementValue as SimpleFilterFieldLeafNode, value)\n      ) {\n        // Single-leaf statement \u2014 remove it.\n        group.children.splice(i, 1);\n        if (group.children.length === 1) {\n          recursiveClearExplicitGroup(group);\n        }\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\nfunction recursiveClearExplicitGroup(group: SimpleFilterFieldGroupNode): void {\n  group.explicit = false;\n  if (group.children.length <= 1) {\n    group.explicitLogicalOperator = false;\n  }\n  if (\n    group.children.length === 1 &&\n    isFilterFieldGroupNode(group.children[0])\n  ) {\n    recursiveClearExplicitGroup(group.children[0]);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,175 @@
+import { getNumberParser } from "../../parser/getNumberParser.js";
+import {
+  isFilterFieldGroupNode,
+  isFilterFieldListNode,
+  isFilterFieldStatementNode
+} from "../tree-node-guards.js";
+const DURATION_REGEX = /^(\d+)(ns|ms|s|m|h|d)$/i;
+const VARIABLE_REGEX = /^\$[A-Za-z_]\w*$/;
+const OPERATOR_MAP = {
+  equals: {
+    node: { type: "ComparisonOperator", value: "=" },
+    polarity: "positive"
+  },
+  "not-equals": {
+    node: { type: "ComparisonOperator", value: "!=" },
+    polarity: "negative"
+  },
+  in: {
+    node: { type: "InclusionOperator", value: "in" },
+    polarity: "positive"
+  },
+  "not in": {
+    node: { type: "InclusionOperator", value: "not in" },
+    polarity: "negative"
+  },
+  "less-than": {
+    node: { type: "ComparisonOperator", value: "<" },
+    polarity: "none"
+  },
+  "less-or-equal": {
+    node: { type: "ComparisonOperator", value: "<=" },
+    polarity: "none"
+  },
+  "greater-than": {
+    node: { type: "ComparisonOperator", value: ">" },
+    polarity: "none"
+  },
+  "greater-or-equal": {
+    node: { type: "ComparisonOperator", value: ">=" },
+    polarity: "none"
+  },
+  exists: { node: { type: "ExistsOperator", value: true }, polarity: "none" },
+  "not-exists": {
+    node: { type: "ExistsOperator", value: false },
+    polarity: "none"
+  },
+  search: {
+    node: { type: "SearchOperator", value: "search" },
+    polarity: "none"
+  }
+};
+function mapInputOperator(operator) {
+  const op = operator ?? "equals";
+  return OPERATOR_MAP[op] ?? {
+    node: {
+      type: "ComparisonOperator",
+      value: op
+    },
+    polarity: "none"
+  };
+}
+function statementPolarity(statement) {
+  const op = statement.comparisonOperator;
+  if (!op) {
+    return "none";
+  }
+  if (op.type === "ComparisonOperator") {
+    if (op.value === "=") {
+      return "positive";
+    }
+    if (op.value === "!=") {
+      return "negative";
+    }
+  }
+  if (op.type === "InclusionOperator") {
+    if (op.value === "in") {
+      return "positive";
+    }
+    if (op.value === "not in") {
+      return "negative";
+    }
+  }
+  return "none";
+}
+function leafEquals(leaf, value) {
+  switch (leaf.type) {
+    case "Number":
+      if (typeof value === "number") {
+        return leaf.value === value;
+      }
+      if (typeof value === "string") {
+        const asNumber = getNumberParser().parse(value);
+        return !isNaN(asNumber) && leaf.value === asNumber;
+      }
+      return false;
+    case "Boolean":
+      if (typeof value === "boolean") {
+        return leaf.value === value;
+      }
+      if (value === "true" || value === "false") {
+        return leaf.value === (value === "true");
+      }
+      return false;
+    // Duration compares against its rendered form (`30m`) so a string input
+    // and an existing Duration leaf deduplicate correctly.
+    case "Duration":
+      return typeof value === "string" && value === `${leaf.value}${leaf.unit}`;
+    case "String":
+    case "IPAddress":
+    case "Timestamp":
+    case "UID":
+    case "SmartscapeId":
+    case "Variable":
+      return typeof value === "string" && leaf.value === value;
+    default:
+      return false;
+  }
+}
+function findSearchStatement(group, value) {
+  for (let i = group.children.length - 1; i >= 0; i--) {
+    const child = group.children[i];
+    if (isFilterFieldGroupNode(child)) {
+      const nested = findSearchStatement(child, value);
+      if (nested) {
+        return nested;
+      }
+    } else if (isFilterFieldStatementNode(child)) {
+      const op = child.comparisonOperator;
+      const leafValue = child.value;
+      if (op?.type === "SearchOperator" && leafValue !== void 0 && !isFilterFieldListNode(leafValue) && leafEquals(leafValue, value)) {
+        return child;
+      }
+    }
+  }
+  return void 0;
+}
+function findIdenticalStatement(group, key, operatorNode, value) {
+  for (let i = group.children.length - 1; i >= 0; i--) {
+    const child = group.children[i];
+    if (isFilterFieldGroupNode(child)) {
+      const nested = findIdenticalStatement(child, key, operatorNode, value);
+      if (nested) {
+        return nested;
+      }
+    } else if (isFilterFieldStatementNode(child)) {
+      const childKey = child.key;
+      if (!childKey || childKey.type !== "Key" && childKey.type !== "JSONPath" || childKey.value !== key) {
+        continue;
+      }
+      const childOp = child.comparisonOperator;
+      if (!childOp || childOp.type !== operatorNode.type || childOp.value !== operatorNode.value) {
+        continue;
+      }
+      if (operatorNode.type === "ExistsOperator" || value === void 0) {
+        return child;
+      }
+      const childValue = child.value;
+      if (childValue && !isFilterFieldListNode(childValue) && childValue.type !== "Error" && leafEquals(childValue, value)) {
+        return child;
+      }
+    }
+  }
+  return void 0;
+}
+export {
+  DURATION_REGEX,
+  OPERATOR_MAP,
+  VARIABLE_REGEX,
+  findIdenticalStatement,
+  findSearchStatement,
+  leafEquals,
+  mapInputOperator,
+  statementPolarity
+};
+//# sourceMappingURL=value-operation-utils.js.map