@dynatrace/strato-components 3.6.0 → 3.7.1

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

@@ -0,0 +1,210 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var add_filter_exports = {};
+__export(add_filter_exports, {
+  addFilter: () => addFilter
+});
+module.exports = __toCommonJS(add_filter_exports);
+var import_value_operation_utils = require("./value-operation-utils.js");
+var import_getNumberParser = require("../../parser/getNumberParser.js");
+var import_string_tree_conversion = require("../conversion/string-tree-conversion.js");
+var import_tree_string_conversion = require("../conversion/tree-string-conversion.js");
+var import_tree_node_guards = require("../tree-node-guards.js");
+var import_operator_specification = require("../validation-utils/operator-specification.js");
+var import_type_validators = require("../validation-utils/type-validators.js");
+function addFilter(currentValue, filter, options) {
+  const parserConfig = {
+    searchConversion: true,
+    ...options?.parserConfig
+  };
+  const { tree } = (0, import_string_tree_conversion.convertStringToFilterFieldTree)(currentValue, {
+    validatorMap: { comparisonOperators: import_operator_specification.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 = (0, import_value_operation_utils.mapInputOperator)(filter.comparisonOperator);
+  if (operator.node.type === "SearchOperator" && filter.value !== void 0 && (0, import_value_operation_utils.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 ((0, import_tree_node_guards.isFilterFieldListNode)(existingValue) && inputValue !== void 0) {
+      const list = existingValue;
+      if (list.value.some((leaf) => (0, import_value_operation_utils.leafEquals)(leaf, inputValue))) {
+        return { updatedStatement: false, value: currentValue };
+      }
+      list.value.push(makeLeaf(inputValue, parserConfig));
+      return {
+        updatedStatement: true,
+        value: (0, import_tree_string_conversion.convertFilterFieldTreeToString)(rootGroup)
+      };
+    }
+    if (existingValue && !(0, import_tree_node_guards.isFilterFieldListNode)(existingValue) && existingValue.type !== "Error" && inputValue !== void 0) {
+      const existingLeaf = existingValue;
+      const valuesEqual = (0, import_value_operation_utils.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: (0, import_tree_string_conversion.convertFilterFieldTreeToString)(rootGroup)
+      };
+    }
+  }
+  if (operator.polarity === "none" && filter.key !== void 0 && (0, import_value_operation_utils.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: (0, import_tree_string_conversion.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 && (0, import_tree_node_guards.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 ((0, import_tree_node_guards.isFilterFieldGroupNode)(child)) {
+      const nested = findRightmostMatchingStatement(child, key, polarity);
+      if (nested) {
+        return nested;
+      }
+    } else if ((0, import_tree_node_guards.isFilterFieldStatementNode)(child)) {
+      const childKey = child.key;
+      if (childKey && (childKey.type === "Key" || childKey.type === "JSONPath") && childKey.value === key && (0, import_value_operation_utils.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 = import_value_operation_utils.DURATION_REGEX.exec(value);
+  if (durationMatch) {
+    return {
+      type: "Duration",
+      value: parseInt(durationMatch[1], 10),
+      unit: durationMatch[2].toLowerCase()
+    };
+  }
+  if (value === "true" || value === "false") {
+    return { type: "Boolean", value: value === "true" };
+  }
+  const parsedNumber = (0, import_getNumberParser.getNumberParser)().parse(value);
+  if (!isNaN(parsedNumber)) {
+    return { type: "Number", value: parsedNumber };
+  }
+  if (import_value_operation_utils.VARIABLE_REGEX.test(value)) {
+    return { type: "Variable", value, variableType: "Any" };
+  }
+  if (parserConfig?.ipAddressConversion && (0, import_type_validators.isValidIPAddress)(value)) {
+    return { type: "IPAddress", value, textValue: value };
+  }
+  if (parserConfig?.timestampConversion && (0, import_type_validators.isValidTimestamp)(value)) {
+    return { type: "Timestamp", value, textValue: value };
+  }
+  if (parserConfig?.uidConversion && (0, import_type_validators.isValidUID)(value)) {
+    return { type: "UID", value, textValue: value };
+  }
+  if (parserConfig?.smartscapeIdConversion && (0, import_type_validators.isValidSmartscapeId)(value)) {
+    return { type: "SmartscapeId", value, textValue: value };
+  }
+  return { type: "String", value };
+}
+function createKey(keyString, parserConfig) {
+  if (parserConfig?.jsonPathConversion && keyString.includes("$")) {
+    const { tree } = (0, import_string_tree_conversion.convertStringToFilterFieldTree)(`${keyString} = x`, {
+      parserConfig
+    });
+    const statement = tree?.children.find(import_tree_node_guards.isFilterFieldStatementNode);
+    if (statement?.key?.type === "JSONPath") {
+      return statement.key;
+    }
+  }
+  return { type: "Key", value: keyString };
+}

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

@@ -0,0 +1,18 @@
+import type { FilterFieldValueOperationResult, FilterFieldValueOperationStatement } from '../../types/value-operations.js';
+/**
+ * Removes a filter statement or value from an existing FilterField value string.
+ *
+ * - If the value is not present for the specified key, the statement is not changed.
+ * - If removing a value from `key in (v1, v2)` leaves one value, the statement collapses to `key = v1`.
+ * - When multiple statements with the same key, operator and value exist, the rightmost one (in document order) is removed.
+ * - When `options.removeAll` is `true`, all matching occurrences are removed instead of only the rightmost one.
+ *
+ * @public
+ * @param currentValue - The current FilterField value string.
+ * @param filter - The filter statement or value to remove.
+ * @param options - Optional configuration for the remove operation.
+ * @returns The new FilterField value string and whether the operation produced a change.
+ */
+export declare function removeFilter(currentValue: string, filter: FilterFieldValueOperationStatement, options?: {
+    removeAll?: boolean;
+}): FilterFieldValueOperationResult;

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

@@ -0,0 +1,190 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var remove_filter_exports = {};
+__export(remove_filter_exports, {
+  removeFilter: () => removeFilter
+});
+module.exports = __toCommonJS(remove_filter_exports);
+var import_value_operation_utils = require("./value-operation-utils.js");
+var import_string_tree_conversion = require("../conversion/string-tree-conversion.js");
+var import_tree_string_conversion = require("../conversion/tree-string-conversion.js");
+var import_tree_node_guards = require("../tree-node-guards.js");
+var import_operator_specification = require("../validation-utils/operator-specification.js");
+function removeFilter(currentValue, filter, options) {
+  const { tree } = (0, import_string_tree_conversion.convertStringToFilterFieldTree)(currentValue, {
+    validatorMap: {
+      comparisonOperators: [...import_operator_specification.FILTERFIELD_ALL_OPERATORS]
+    },
+    parserConfig: { searchConversion: true }
+  });
+  if (!tree) {
+    return { updatedStatement: false, value: currentValue };
+  }
+  const operator = (0, import_value_operation_utils.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 && !(0, import_tree_node_guards.isFilterFieldListNode)(statementValue) && (0, import_value_operation_utils.leafEquals)(
+          statementValue,
+          filter.value
+        );
+      });
+      if (!found) {
+        break;
+      }
+      updatedStatement = true;
+    } while (options?.removeAll);
+    return updatedStatement ? { updatedStatement: true, value: (0, import_tree_string_conversion.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 && !(0, import_tree_node_guards.isFilterFieldListNode)(statementValue) && statementValue.type !== "Error" && (0, import_value_operation_utils.leafEquals)(statementValue, filter.value);
+      });
+      if (!found) {
+        break;
+      }
+      updatedStatement = true;
+    } while (options?.removeAll);
+    return updatedStatement ? { updatedStatement: true, value: (0, import_tree_string_conversion.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: (0, import_tree_string_conversion.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 ((0, import_tree_node_guards.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 ((0, import_tree_node_guards.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 ((0, import_tree_node_guards.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 ((0, import_tree_node_guards.isFilterFieldStatementNode)(child)) {
+      const statementKey = child.key;
+      if (!statementKey || statementKey.type !== "Key" && statementKey.type !== "JSONPath" || statementKey.value !== key || (0, import_value_operation_utils.statementPolarity)(child) !== polarity) {
+        continue;
+      }
+      const statementValue = child.value;
+      if (!statementValue) {
+        continue;
+      }
+      if ((0, import_tree_node_guards.isFilterFieldListNode)(statementValue)) {
+        const list = statementValue;
+        const valueIndex = list.value.findIndex(
+          (leaf) => (0, import_value_operation_utils.leafEquals)(leaf, value)
+        );
+        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" && (0, import_value_operation_utils.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 && (0, import_tree_node_guards.isFilterFieldGroupNode)(group.children[0])) {
+    recursiveClearExplicitGroup(group.children[0]);
+  }
+}

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

@@ -0,0 +1,26 @@
+import type { SimpleFilterFieldComparisonOperatorNode, SimpleFilterFieldExistsOperatorNode, SimpleFilterFieldGroupNode, SimpleFilterFieldInclusionOperatorNode, SimpleFilterFieldLeafNode, SimpleFilterFieldSearchOperatorNode, SimpleFilterFieldStatementNode } from '../../types/conversion-tree-nodes.js';
+/** @internal */
+export declare const DURATION_REGEX: RegExp;
+/** @internal */
+export declare const VARIABLE_REGEX: RegExp;
+/** @internal */
+export type NewOperatorNode = SimpleFilterFieldComparisonOperatorNode | SimpleFilterFieldInclusionOperatorNode | SimpleFilterFieldExistsOperatorNode | SimpleFilterFieldSearchOperatorNode;
+/** @internal */
+export type Polarity = 'positive' | 'negative' | 'none';
+/** @internal */
+export type OperatorDescriptor = {
+    node: NewOperatorNode;
+    polarity: Polarity;
+};
+/** @internal */
+export declare const OPERATOR_MAP: Partial<Record<string, OperatorDescriptor>>;
+/** @internal */
+export declare function mapInputOperator(operator: string | undefined): OperatorDescriptor;
+/** @internal */
+export declare function statementPolarity(statement: SimpleFilterFieldStatementNode): Polarity;
+/** @internal */
+export declare function leafEquals(leaf: SimpleFilterFieldLeafNode, value: string | number | boolean): boolean;
+/** @internal */
+export declare function findSearchStatement(group: SimpleFilterFieldGroupNode, value: string | number | boolean): SimpleFilterFieldStatementNode | undefined;
+/** @internal */
+export declare function findIdenticalStatement(group: SimpleFilterFieldGroupNode, key: string, operatorNode: NewOperatorNode, value: string | number | boolean | undefined): SimpleFilterFieldStatementNode | undefined;

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

@@ -0,0 +1,189 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var value_operation_utils_exports = {};
+__export(value_operation_utils_exports, {
+  DURATION_REGEX: () => DURATION_REGEX,
+  OPERATOR_MAP: () => OPERATOR_MAP,
+  VARIABLE_REGEX: () => VARIABLE_REGEX,
+  findIdenticalStatement: () => findIdenticalStatement,
+  findSearchStatement: () => findSearchStatement,
+  leafEquals: () => leafEquals,
+  mapInputOperator: () => mapInputOperator,
+  statementPolarity: () => statementPolarity
+});
+module.exports = __toCommonJS(value_operation_utils_exports);
+var import_getNumberParser = require("../../parser/getNumberParser.js");
+var import_tree_node_guards = require("../tree-node-guards.js");
+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 = (0, import_getNumberParser.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 ((0, import_tree_node_guards.isFilterFieldGroupNode)(child)) {
+      const nested = findSearchStatement(child, value);
+      if (nested) {
+        return nested;
+      }
+    } else if ((0, import_tree_node_guards.isFilterFieldStatementNode)(child)) {
+      const op = child.comparisonOperator;
+      const leafValue = child.value;
+      if (op?.type === "SearchOperator" && leafValue !== void 0 && !(0, import_tree_node_guards.isFilterFieldListNode)(leafValue) && leafEquals(leafValue, value)) {
+        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 ((0, import_tree_node_guards.isFilterFieldGroupNode)(child)) {
+      const nested = findIdenticalStatement(child, key, operatorNode, value);
+      if (nested) {
+        return nested;
+      }
+    } else if ((0, import_tree_node_guards.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 && !(0, import_tree_node_guards.isFilterFieldListNode)(childValue) && childValue.type !== "Error" && leafEquals(childValue, value)) {
+        return child;
+      }
+    }
+  }
+  return void 0;
+}

package/filters/index.d.ts

@@ -21,6 +21,9 @@ export { isFilterFieldLeafNode, isFilterFieldListNode, } from './filter-field/ut
 export { escapeSuggestion as escapeFilterFieldSuggestion } from './filter-field/utils/escape-suggestion.js';
 export { convertStringToFilterFieldTree } from './filter-field/utils/conversion/string-tree-conversion.js';
 export { convertFilterFieldTreeToString } from './filter-field/utils/conversion/tree-string-conversion.js';
+export { addFilter } from './filter-field/utils/value-operations/add-filter.js';
+export { removeFilter } from './filter-field/utils/value-operations/remove-filter.js';
+export type { FilterFieldValueOperationStatement, FilterFieldValueOperationResult, } from './filter-field/types/value-operations.js';
 export { FILTERFIELD_DEFAULT_OPERATORS } from './filter-field/utils/validation-utils/operator-specification.js';
 export { migrateFilterFieldKeyPredicatesToArray } from './filter-field/utils/migrate-validator-map.js';
 export { SegmentSelector } from './segment-selector/SegmentSelector.js';

package/filters/index.js

@@ -25,12 +25,14 @@ __export(filters_exports, {
   TIMEFRAME_SELECTOR_PRESETS: () => import_timeframe_presets.TIMEFRAME_SELECTOR_PRESETS,
   TimeframeSelector: () => import_TimeframeSelector.TimeframeSelector,
   _FilterStatement: () => import_FilterStatement.FilterStatement,
+  addFilter: () => import_add_filter.addFilter,
   convertFilterFieldTreeToString: () => import_tree_string_conversion.convertFilterFieldTreeToString,
   convertStringToFilterFieldTree: () => import_string_tree_conversion.convertStringToFilterFieldTree,
   escapeFilterFieldSuggestion: () => import_escape_suggestion.escapeSuggestion,
   isFilterFieldLeafNode: () => import_tree_node_guards.isFilterFieldLeafNode,
   isFilterFieldListNode: () => import_tree_node_guards.isFilterFieldListNode,
   migrateFilterFieldKeyPredicatesToArray: () => import_migrate_validator_map.migrateFilterFieldKeyPredicatesToArray,
+  removeFilter: () => import_remove_filter.removeFilter,
   useSegments: () => import_useSegments.useSegments
 });
 module.exports = __toCommonJS(filters_exports);
@@ -41,6 +43,8 @@ var import_tree_node_guards = require("./filter-field/utils/tree-node-guards.js"
 var import_escape_suggestion = require("./filter-field/utils/escape-suggestion.js");
 var import_string_tree_conversion = require("./filter-field/utils/conversion/string-tree-conversion.js");
 var import_tree_string_conversion = require("./filter-field/utils/conversion/tree-string-conversion.js");
+var import_add_filter = require("./filter-field/utils/value-operations/add-filter.js");
+var import_remove_filter = require("./filter-field/utils/value-operations/remove-filter.js");
 var import_operator_specification = require("./filter-field/utils/validation-utils/operator-specification.js");
 var import_migrate_validator_map = require("./filter-field/utils/migrate-validator-map.js");
 var import_SegmentSelector = require("./segment-selector/SegmentSelector.js");