@multiplatform.one/frappe 6.0.0

package/dist/cjs/sync/filters.native.js

@@ -0,0 +1,446 @@
+"use strict";
+
+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 filters_exports = {};
+__export(filters_exports, {
+  FilterOperator: () => FilterOperator,
+  canEvaluateClientSide: () => canEvaluateClientSide,
+  extractFilterFields: () => extractFilterFields,
+  extractSingleName: () => extractSingleName,
+  formatFilter: () => formatFilter,
+  getClientEvaluationBlockers: () => getClientEvaluationBlockers,
+  hasServerOnlyOperators: () => hasServerOnlyOperators,
+  isTreeOperator: () => isTreeOperator,
+  matchesFilters: () => matchesFilters,
+  normalizeFilters: () => normalizeFilters,
+  validateFilters: () => validateFilters
+});
+module.exports = __toCommonJS(filters_exports);
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var FilterOperator = /* @__PURE__ */function (FilterOperator2) {
+  FilterOperator2["AncestorsOf"] = "ancestors of";
+  FilterOperator2["Between"] = "between";
+  FilterOperator2["DescendantsOf"] = "descendants of";
+  FilterOperator2["DoubleEquals"] = "==";
+  FilterOperator2["Equals"] = "=";
+  FilterOperator2["GreaterThan"] = ">";
+  FilterOperator2["GreaterThanOrEqual"] = ">=";
+  FilterOperator2["In"] = "in";
+  FilterOperator2["Is"] = "is";
+  FilterOperator2["IsNot"] = "is not";
+  FilterOperator2["LessThan"] = "<";
+  FilterOperator2["LessThanOrEqual"] = "<=";
+  FilterOperator2["Like"] = "like";
+  FilterOperator2["NotAncestorsOf"] = "not ancestors of";
+  FilterOperator2["NotDescendantsOf"] = "not descendants of";
+  FilterOperator2["NotEquals"] = "!=";
+  FilterOperator2["NotEqualsAngle"] = "<>";
+  FilterOperator2["NotIn"] = "not in";
+  FilterOperator2["NotLike"] = "not like";
+  return FilterOperator2;
+}({});
+function normalizeOperator(operator) {
+  return String(operator).toLowerCase();
+}
+function matchesFilters(doc, filters) {
+  if (!filters) return true;
+  if (Array.isArray(filters)) {
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = filters[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var filterTuple = _step.value;
+        var [fieldName, operatorRaw, expectedValue] = filterTuple;
+        var documentValue = doc === null || doc === void 0 ? void 0 : doc[fieldName];
+        var operator = normalizeOperator(operatorRaw);
+        if (!evaluateFilterCondition(documentValue, operator, expectedValue)) {
+          return false;
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    return true;
+  }
+  if ((typeof filters === "undefined" ? "undefined" : _type_of(filters)) === "object") {
+    var _iteratorNormalCompletion1 = true,
+      _didIteratorError1 = false,
+      _iteratorError1 = void 0;
+    try {
+      for (var _iterator1 = Object.entries(filters)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+        var [fieldName1, expectedValue1] = _step1.value;
+        if ((doc === null || doc === void 0 ? void 0 : doc[fieldName1]) !== expectedValue1) return false;
+      }
+    } catch (err) {
+      _didIteratorError1 = true;
+      _iteratorError1 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+          _iterator1.return();
+        }
+      } finally {
+        if (_didIteratorError1) {
+          throw _iteratorError1;
+        }
+      }
+    }
+    return true;
+  }
+  return true;
+}
+function isOperator(operator) {
+  for (var _len = arguments.length, enumValues = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    enumValues[_key - 1] = arguments[_key];
+  }
+  return enumValues.some(function (enumValue) {
+    return enumValue.toLowerCase() === operator.toLowerCase();
+  });
+}
+function areComparableValues(a, b) {
+  return a != null && b != null && (typeof a === "number" || typeof a === "string") && (typeof b === "number" || typeof b === "string");
+}
+function compareAsNumbers(a, b, comparison) {
+  if (!areComparableValues(a, b)) return false;
+  var numberA = Number(a);
+  var numberB = Number(b);
+  if (Number.isNaN(numberA) || Number.isNaN(numberB)) return false;
+  return comparison(numberA, numberB);
+}
+function evaluateFilterCondition(documentValue, operator, expectedValue) {
+  if (isOperator(operator, "=", "==")) {
+    return documentValue === expectedValue;
+  }
+  if (isOperator(operator, "!=", "<>")) {
+    return documentValue !== expectedValue;
+  }
+  if (isOperator(operator, "<")) {
+    return compareAsNumbers(documentValue, expectedValue, function (a, b) {
+      return a < b;
+    });
+  }
+  if (isOperator(operator, "<=")) {
+    return compareAsNumbers(documentValue, expectedValue, function (a, b) {
+      return a <= b;
+    });
+  }
+  if (isOperator(operator, ">")) {
+    return compareAsNumbers(documentValue, expectedValue, function (a, b) {
+      return a > b;
+    });
+  }
+  if (isOperator(operator, ">=")) {
+    return compareAsNumbers(documentValue, expectedValue, function (a, b) {
+      return a >= b;
+    });
+  }
+  if (isOperator(operator, "in")) {
+    return Array.isArray(expectedValue) && expectedValue.includes(documentValue);
+  }
+  if (isOperator(operator, "not in")) {
+    return !Array.isArray(expectedValue) || !expectedValue.includes(documentValue);
+  }
+  if (isOperator(operator, "like")) {
+    return evaluateLikePattern(documentValue, expectedValue, false);
+  }
+  if (isOperator(operator, "not like")) {
+    return !evaluateLikePattern(documentValue, expectedValue, false);
+  }
+  if (isOperator(operator, "is") && (expectedValue === null || expectedValue === "null")) {
+    return documentValue === null || documentValue === void 0;
+  }
+  if (isOperator(operator, "is not") && (expectedValue === null || expectedValue === "null")) {
+    return documentValue !== null && documentValue !== void 0;
+  }
+  if (isOperator(operator, "between") && Array.isArray(expectedValue) && expectedValue.length === 2) {
+    var [min, max] = expectedValue;
+    return compareAsNumbers(documentValue, min, function (a, b) {
+      return a >= b;
+    }) && compareAsNumbers(documentValue, max, function (a, b) {
+      return a <= b;
+    });
+  }
+  return false;
+}
+function evaluateLikePattern(documentValue, pattern, negate) {
+  var patternStr = String(pattern || "").toLowerCase();
+  var valueStr = String(documentValue || "").toLowerCase();
+  var matches = false;
+  if (patternStr.startsWith("%") && patternStr.endsWith("%")) {
+    matches = valueStr.includes(patternStr.slice(1, -1));
+  } else if (patternStr.startsWith("%")) {
+    matches = valueStr.endsWith(patternStr.slice(1));
+  } else if (patternStr.endsWith("%")) {
+    matches = valueStr.startsWith(patternStr.slice(0, -1));
+  } else {
+    matches = valueStr.includes(patternStr);
+  }
+  return negate ? !matches : matches;
+}
+function extractSingleName(filters) {
+  if (!filters) return void 0;
+  if (Array.isArray(filters)) {
+    if (filters.length === 1) {
+      var [fieldName, operatorRaw, value] = filters[0];
+      var normalizedOperator = normalizeOperator(operatorRaw);
+      if (fieldName === "name" && isOperator(normalizedOperator, "=", "==")) {
+        return typeof value === "string" ? value : void 0;
+      }
+    }
+    return;
+  }
+  if ((typeof filters === "undefined" ? "undefined" : _type_of(filters)) === "object" && filters.name && typeof filters.name === "string") {
+    return filters.name;
+  }
+}
+var STANDARD_FIELDS = /* @__PURE__ */new Set(["name", "creation", "modified", "modified_by", "owner", "docstatus", "idx", "doctype", "_user_tags", "_comments", "_assign", "_liked_by"]);
+var TEXT_FIELD_TYPES = /* @__PURE__ */new Set(["Data", "Text", "Small Text", "Long Text", "Link", "Select", "Dynamic Link", "Text Editor", "Code", "HTML Editor", "Markdown Editor", "Password", "Read Only"]);
+var COMPARABLE_FIELD_TYPES = /* @__PURE__ */new Set(["Int", "Float", "Currency", "Percent", "Date", "Datetime", "Time", "Duration", "Rating"]);
+var VALID_OPERATORS = new Set(Object.values(FilterOperator).map(function (v) {
+  return v.toLowerCase();
+}));
+function validateFilters(filters, schema) {
+  var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  var errors = [];
+  var warnings = [];
+  var {
+    strict = false
+  } = options;
+  if (!filters) {
+    return {
+      valid: true,
+      errors,
+      warnings
+    };
+  }
+  var fieldMap = new Map(schema.map(function (f) {
+    return [f.fieldname, f];
+  }));
+  if (Array.isArray(filters)) {
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = filters[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var filterTuple = _step.value;
+        var [fieldName, operatorRaw, value] = filterTuple;
+        var schemaField = fieldMap.get(fieldName);
+        var operator = normalizeOperator(operatorRaw);
+        if (!schemaField && !STANDARD_FIELDS.has(fieldName)) {
+          if (strict) {
+            errors.push({
+              field: fieldName,
+              message: `Unknown field "${fieldName}" in doctype schema`,
+              code: "unknown_field"
+            });
+          } else {
+            warnings.push(`Field "${fieldName}" not found in schema - may be a virtual or custom field`);
+          }
+          continue;
+        }
+        if (!VALID_OPERATORS.has(operator)) {
+          errors.push({
+            field: fieldName,
+            message: `Invalid operator "${operatorRaw}" for field "${fieldName}"`,
+            code: "invalid_operator"
+          });
+          continue;
+        }
+        if (schemaField) {
+          var fieldType = schemaField.fieldtype;
+          if (isOperator(operator, "like", "not like") && !TEXT_FIELD_TYPES.has(fieldType)) {
+            warnings.push(`LIKE operator on non-text field "${fieldName}" (${fieldType}) may not work as expected`);
+          }
+          if (isOperator(operator, ">", "<", ">=", "<=", "between") && !COMPARABLE_FIELD_TYPES.has(fieldType)) {
+            warnings.push(`Comparison operator on non-numeric/date field "${fieldName}" (${fieldType}) may not work as expected`);
+          }
+          if (isOperator(operator, "in", "not in") && !Array.isArray(value)) {
+            errors.push({
+              field: fieldName,
+              message: `IN/NOT IN operator requires an array value for field "${fieldName}"`,
+              code: "invalid_value"
+            });
+          }
+          if (isOperator(operator, "between")) {
+            if (!Array.isArray(value) || value.length !== 2) {
+              errors.push({
+                field: fieldName,
+                message: `BETWEEN operator requires an array of exactly 2 values for field "${fieldName}"`,
+                code: "invalid_value"
+              });
+            }
+          }
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  } else if ((typeof filters === "undefined" ? "undefined" : _type_of(filters)) === "object") {
+    var _iteratorNormalCompletion1 = true,
+      _didIteratorError1 = false,
+      _iteratorError1 = void 0;
+    try {
+      for (var _iterator1 = Object.keys(filters)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+        var fieldName1 = _step1.value;
+        var schemaField1 = fieldMap.get(fieldName1);
+        if (!schemaField1 && !STANDARD_FIELDS.has(fieldName1)) {
+          if (strict) {
+            errors.push({
+              field: fieldName1,
+              message: `Unknown field "${fieldName1}" in doctype schema`,
+              code: "unknown_field"
+            });
+          } else {
+            warnings.push(`Field "${fieldName1}" not found in schema - may be a virtual or custom field`);
+          }
+        }
+      }
+    } catch (err) {
+      _didIteratorError1 = true;
+      _iteratorError1 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+          _iterator1.return();
+        }
+      } finally {
+        if (_didIteratorError1) {
+          throw _iteratorError1;
+        }
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function normalizeFilters(filters) {
+  if (!filters) return [];
+  if (Array.isArray(filters)) {
+    return filters;
+  }
+  return Object.entries(filters).map(function (param) {
+    var [field, value] = param;
+    return [field, "=", value];
+  });
+}
+function extractFilterFields(filters) {
+  if (!filters) return [];
+  var normalized = normalizeFilters(filters);
+  return [...new Set(normalized.map(function (c) {
+    return c[0];
+  }))];
+}
+function formatFilter(condition) {
+  var [field, operator, value] = condition;
+  var displayValue;
+  if (value === null || value === void 0) {
+    displayValue = "null";
+  } else if (Array.isArray(value)) {
+    displayValue = "[" + value.map(function (v) {
+      return JSON.stringify(v);
+    }).join(", ") + "]";
+  } else if (typeof value === "string") {
+    displayValue = JSON.stringify(value);
+  } else {
+    displayValue = String(value);
+  }
+  return `${field} ${operator} ${displayValue}`;
+}
+var SERVER_ONLY_OPERATORS = /* @__PURE__ */new Set(["ancestors of".toLowerCase(), "descendants of".toLowerCase(), "not ancestors of".toLowerCase(), "not descendants of".toLowerCase()]);
+function hasServerOnlyOperators(filters) {
+  if (!filters) return false;
+  var normalized = normalizeFilters(filters);
+  return normalized.some(function (param) {
+    var [, operator] = param;
+    return SERVER_ONLY_OPERATORS.has(normalizeOperator(operator));
+  });
+}
+function canEvaluateClientSide(filters) {
+  return !hasServerOnlyOperators(filters);
+}
+function isTreeOperator(operator) {
+  return SERVER_ONLY_OPERATORS.has(normalizeOperator(operator));
+}
+function getClientEvaluationBlockers(filters) {
+  if (!filters) return [];
+  var blockers = [];
+  var normalized = normalizeFilters(filters);
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = normalized[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [field, operator] = _step.value;
+      var normalizedOp = normalizeOperator(operator);
+      if (SERVER_ONLY_OPERATORS.has(normalizedOp)) {
+        blockers.push(`Field "${field}" uses tree operator "${operator}" which requires server-side evaluation`);
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return blockers;
+}
+//# sourceMappingURL=filters.native.js.map

package/dist/cjs/sync/filters.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","filters_exports","__export","FilterOperator","canEvaluateClientSide","extractFilterFields","extractSingleName","formatFilter","getClientEvaluationBlockers","hasServerOnlyOperators","isTreeOperator","matchesFilters","normalizeFilters","validateFilters","module","exports","_type_of","obj","Symbol","constructor","FilterOperator2","normalizeOperator","operator","String","toLowerCase","doc","filters","Array","isArray","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","iterator","_step","next","done","filterTuple","fieldName","operatorRaw","expectedValue","documentValue","evaluateFilterCondition","err","return","_iteratorNormalCompletion1","_didIteratorError1","_iteratorError1","_iterator1","Object","entries","_step1","fieldName1","expectedValue1","isOperator","_len","arguments","length","enumValues","_key","some","enumValue","areComparableValues","a","b","compareAsNumbers","comparison","numberA","Number","numberB","isNaN","includes","evaluateLikePattern","min","max","pattern","negate","patternStr","valueStr","matches","startsWith","endsWith","slice","normalizedOperator","name","STANDARD_FIELDS","Set","TEXT_FIELD_TYPES","COMPARABLE_FIELD_TYPES","VALID_OPERATORS","values","map","v","schema","options","errors","warnings","strict","valid","fieldMap","Map","f","fieldname","schemaField","get","has","push","field","message","code","fieldType","fieldtype","keys","schemaField1"],"sources":["../../../src/sync/filters.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/sync/filters.spec.cjs

@@ -0,0 +1,168 @@
+var import_vitest = require("vitest");
+var import_filters = require("./filters.cjs");
+(0, import_vitest.describe)("matchesFilters", () => {
+  const testDoc = {
+    name: "TEST-001",
+    doctype: "Task",
+    status: "Open",
+    priority: 5,
+    tags: ["urgent", "customer"],
+    assignee: "john@example.com",
+    created: "2024-01-01",
+    amount: 1e3,
+    description: "Test document for filter testing",
+    parent: "PARENT-001"
+  };
+  (0, import_vitest.describe)("array-style filters", () => {
+    (0, import_vitest.it)("should handle equals operator", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "=", "Open"]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "=", "Closed"]])).toBe(false);
+    });
+    (0, import_vitest.it)("should handle not equals operator", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "!=", "Closed"]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "!=", "Open"]])).toBe(false);
+    });
+    (0, import_vitest.it)("should handle greater than operators", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", ">", 3]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", ">", 5]])).toBe(false);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", ">=", 5]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", ">=", 6]])).toBe(false);
+    });
+    (0, import_vitest.it)("should handle less than operators", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", "<", 10]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", "<", 5]])).toBe(false);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", "<=", 5]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", "<=", 4]])).toBe(false);
+    });
+    (0, import_vitest.it)("should handle 'in' operator", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "in", ["Open", "Closed"]]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "in", ["Closed", "Cancelled"]]])).toBe(false);
+    });
+    (0, import_vitest.it)("should handle 'not in' operator", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "not in", ["Closed", "Cancelled"]]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "not in", ["Open", "Closed"]]])).toBe(false);
+    });
+    (0, import_vitest.it)("should handle 'like' operator", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["assignee", "like", "%john%"]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["assignee", "like", "%jane%"]])).toBe(false);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["description", "like", "%filter%"]])).toBe(true);
+    });
+    (0, import_vitest.it)("should handle 'not like' operator", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["assignee", "not like", "%jane%"]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["assignee", "not like", "%john%"]])).toBe(false);
+    });
+    (0, import_vitest.it)("should handle 'between' operator", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", "between", [1, 10]]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", "between", [6, 10]]])).toBe(false);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["amount", "between", [500, 1500]]])).toBe(true);
+    });
+    (0, import_vitest.it)("should handle multiple filters (AND logic)", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "=", "Open"], ["priority", ">", 3]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "=", "Open"], ["priority", ">", 10]])).toBe(false);
+    });
+    (0, import_vitest.it)("should handle FilterOperator enum values", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", import_filters.FilterOperator.Equals, "Open"]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", import_filters.FilterOperator.GreaterThan, 3]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["assignee", import_filters.FilterOperator.Like, "%john%"]])).toBe(true);
+    });
+    (0, import_vitest.it)("should handle 'is' operator for null/not null", () => {
+      const docWithNull = {
+        ...testDoc,
+        nullField: null,
+        notNullField: "value"
+      };
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(docWithNull, [["nullField", "is", null]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(docWithNull, [["notNullField", "is", null]])).toBe(false);
+    });
+    (0, import_vitest.it)("should handle 'ancestors of' operator", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["parent", "ancestors of", "PARENT-001"]])).toBe(false);
+    });
+    (0, import_vitest.it)("should return false for unsupported operators", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "unknown-operator", "Open"]])).toBe(false);
+    });
+  });
+  (0, import_vitest.describe)("object-style filters", () => {
+    (0, import_vitest.it)("should handle simple equality filters", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, {
+        status: "Open"
+      })).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, {
+        status: "Closed"
+      })).toBe(false);
+    });
+    (0, import_vitest.it)("should handle multiple fields (AND logic)", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, {
+        status: "Open",
+        priority: 5
+      })).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, {
+        status: "Open",
+        priority: 10
+      })).toBe(false);
+    });
+  });
+  (0, import_vitest.describe)("edge cases", () => {
+    (0, import_vitest.it)("should handle empty filters", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, {})).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, null)).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, void 0)).toBe(true);
+    });
+    (0, import_vitest.it)("should handle missing fields in document", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["nonExistentField", "=", "value"]])).toBe(false);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["nonExistentField", "!=", "value"]])).toBe(true);
+    });
+    (0, import_vitest.it)("should handle array fields in documents", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["tags", "in", ["urgent"]]])).toBe(false);
+      const docWithArrayCheck = {
+        ...testDoc,
+        singleTag: "urgent"
+      };
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(docWithArrayCheck, [["singleTag", "in", ["urgent", "low"]]])).toBe(true);
+    });
+    (0, import_vitest.it)("should handle case sensitivity", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "LIKE", "%Open%"]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["priority", "BETWEEN", [1, 10]]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "=", "open"]])).toBe(false);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["status", "=", "Open"]])).toBe(true);
+    });
+    (0, import_vitest.it)("should handle type coercion in comparisons", () => {
+      const docWithStringNumber = {
+        ...testDoc,
+        stringPriority: "5"
+      };
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(docWithStringNumber, [["stringPriority", ">", 3]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(docWithStringNumber, [["stringPriority", "<", 10]])).toBe(true);
+    });
+    (0, import_vitest.it)("should handle date comparisons", () => {
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["created", "=", "2024-01-01"]])).toBe(true);
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(testDoc, [["created", "!=", "2024-01-02"]])).toBe(true);
+    });
+    (0, import_vitest.it)("should handle complex nested documents", () => {
+      const nestedDoc = {
+        name: "NESTED-001",
+        doctype: "NestedDoc",
+        data: {
+          level1: {
+            level2: {
+              value: "deep-value"
+            }
+          }
+        }
+      };
+      (0, import_vitest.expect)((0, import_filters.matchesFilters)(nestedDoc, [["data.level1.level2.value", "=", "deep-value"]])).toBe(false);
+    });
+  });
+  (0, import_vitest.describe)("performance considerations", () => {
+    (0, import_vitest.it)("should handle large filter arrays efficiently", () => {
+      const largeFilterArray = Array.from({
+        length: 100
+      }, (_, i) => ["status", "!=", `status-${i}`]);
+      const start = Date.now();
+      const result = (0, import_filters.matchesFilters)(testDoc, largeFilterArray);
+      const duration = Date.now() - start;
+      (0, import_vitest.expect)(result).toBe(true);
+      (0, import_vitest.expect)(duration).toBeLessThan(100);
+    });
+  });
+});