@multiplatform.one/table 6.0.0

package/dist/jsx/utils/filterUtils.native.js

@@ -0,0 +1,308 @@
+"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 filterUtils_exports = {};
+__export(filterUtils_exports, {
+  applyFilterToValue: () => applyFilterToValue,
+  combineFilters: () => combineFilters,
+  createFilterPreset: () => createFilterPreset,
+  deserializeFilterPresets: () => deserializeFilterPresets,
+  deserializeFilters: () => deserializeFilters,
+  generateFilterId: () => generateFilterId,
+  getFilterDescription: () => getFilterDescription,
+  inferColumnType: () => inferColumnType,
+  serializeFilterPresets: () => serializeFilterPresets,
+  serializeFilters: () => serializeFilters,
+  validateFilter: () => validateFilter
+});
+module.exports = __toCommonJS(filterUtils_exports);
+function _instanceof(left, right) {
+  "@swc/helpers - instanceof";
+
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
+function generateFilterId() {
+  return `filter-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+function serializeFilters(filters) {
+  try {
+    return JSON.stringify(filters);
+  } catch (error) {
+    console.warn("Failed to serialize filters:", error);
+    return "[]";
+  }
+}
+function deserializeFilters(filterString) {
+  try {
+    var parsed = JSON.parse(filterString);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (error) {
+    console.warn("Failed to deserialize filters:", error);
+    return [];
+  }
+}
+function applyFilterToValue(value, filterValue) {
+  var columnType = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "text";
+  var {
+    operator,
+    value: filterVal,
+    values
+  } = filterValue;
+  if (value == null) {
+    return operator === "isEmpty" || operator === "isNotEmpty" ? operator === "isEmpty" : false;
+  }
+  var stringValue = String(value).toLowerCase();
+  var filterStringValue = String(filterVal).toLowerCase();
+  switch (operator) {
+    // Text Filters
+    case "contains":
+      return stringValue.includes(filterStringValue);
+    case "doesNotContain":
+      return !stringValue.includes(filterStringValue);
+    case "startsWith":
+      return stringValue.startsWith(filterStringValue);
+    case "endsWith":
+      return stringValue.endsWith(filterStringValue);
+    case "isEmpty":
+      return value === "" || value == null;
+    case "isNotEmpty":
+      return value !== "" && value != null;
+    // Equality operators - handle different types
+    case "is":
+      if (columnType === "number") {
+        return Number(value) === Number(filterVal);
+      }
+      if (columnType === "boolean") {
+        return Boolean(value) === Boolean(filterVal);
+      }
+      return stringValue === filterStringValue;
+    case "isNot":
+      if (columnType === "number") {
+        return Number(value) !== Number(filterVal);
+      }
+      return stringValue !== filterStringValue;
+    // Number/Date Filters
+    case "isLessThan":
+      return columnType === "number" ? Number(value) < Number(filterVal) : stringValue < filterStringValue;
+    case "isGreaterThan":
+      return columnType === "number" ? Number(value) > Number(filterVal) : stringValue > filterStringValue;
+    case "isLessThanOrEqual":
+      return columnType === "number" ? Number(value) <= Number(filterVal) : stringValue <= filterStringValue;
+    case "isGreaterThanOrEqual":
+      return columnType === "number" ? Number(value) >= Number(filterVal) : stringValue >= filterStringValue;
+    case "isBetween":
+      if (values && values.length >= 2) {
+        var numValue = Number(value);
+        var min = Number(values[0]);
+        var max = Number(values[1]);
+        return numValue >= min && numValue <= max;
+      }
+      return false;
+    case "isNotBetween":
+      if (values && values.length >= 2) {
+        var numValue1 = Number(value);
+        var min1 = Number(values[0]);
+        var max1 = Number(values[1]);
+        return numValue1 < min1 || numValue1 > max1;
+      }
+      return true;
+    // Date Filters
+    case "isBefore":
+      return columnType === "date" ? new Date(value) < new Date(filterVal) : stringValue < filterStringValue;
+    case "isAfter":
+      return columnType === "date" ? new Date(value) > new Date(filterVal) : stringValue > filterStringValue;
+    case "isOnOrBefore":
+      return columnType === "date" ? new Date(value) <= new Date(filterVal) : stringValue <= filterStringValue;
+    case "isOnOrAfter":
+      return columnType === "date" ? new Date(value) >= new Date(filterVal) : stringValue >= filterStringValue;
+    // Option Filters
+    case "isAnyOf":
+      if (values) {
+        return values.some(function (v) {
+          return String(v).toLowerCase() === stringValue;
+        });
+      }
+      return String(filterVal).toLowerCase() === stringValue;
+    case "isNoneOf":
+      if (values) {
+        return !values.some(function (v) {
+          return String(v).toLowerCase() === stringValue;
+        });
+      }
+      return String(filterVal).toLowerCase() !== stringValue;
+    default:
+      return true;
+  }
+}
+function validateFilter(filter) {
+  var _filter_value;
+  var errors = [];
+  if (!filter.columnId) {
+    errors.push("Column ID is required");
+  }
+  if (!((_filter_value = filter.value) === null || _filter_value === void 0 ? void 0 : _filter_value.operator)) {
+    errors.push("Filter operator is required");
+  }
+  var {
+    operator,
+    value,
+    values
+  } = filter.value || {};
+  switch (operator) {
+    case "isBetween":
+    case "isNotBetween":
+      if (!values || values.length < 2) {
+        errors.push("Between operators require at least 2 values");
+      }
+      break;
+    case "isAnyOf":
+    case "isNoneOf":
+      if (!values && !value) {
+        errors.push("Option operators require values array or single value");
+      }
+      break;
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+function combineFilters(filters) {
+  var combinationMode = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "AND";
+  return function (value, columnId) {
+    if (filters.length === 0) return true;
+    var columnFilters = filters.filter(function (f) {
+      return f.columnId === columnId;
+    });
+    if (columnFilters.length === 0) return true;
+    if (combinationMode === "AND") {
+      return columnFilters.every(function (filter) {
+        var columnType = inferColumnType(value);
+        return applyFilterToValue(value, filter.value, columnType);
+      });
+    }
+    return columnFilters.some(function (filter) {
+      var columnType = inferColumnType(value);
+      return applyFilterToValue(value, filter.value, columnType);
+    });
+  };
+}
+function inferColumnType(value) {
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return "number";
+  if (_instanceof(value, Date) || !Number.isNaN(Date.parse(value)) && !Number.isNaN(Number(value))) return "date";
+  return "text";
+}
+function getFilterDescription(filter) {
+  var {
+    operator,
+    value,
+    values
+  } = filter.value;
+  var columnLabel = filter.label || filter.columnId;
+  switch (operator) {
+    case "contains":
+      return `${columnLabel} contains "${value}"`;
+    case "doesNotContain":
+      return `${columnLabel} does not contain "${value}"`;
+    case "is":
+      return `${columnLabel} is "${value}"`;
+    case "isNot":
+      return `${columnLabel} is not "${value}"`;
+    case "startsWith":
+      return `${columnLabel} starts with "${value}"`;
+    case "endsWith":
+      return `${columnLabel} ends with "${value}"`;
+    case "isEmpty":
+      return `${columnLabel} is empty`;
+    case "isNotEmpty":
+      return `${columnLabel} is not empty`;
+    case "isLessThan":
+      return `${columnLabel} < ${value}`;
+    case "isGreaterThan":
+      return `${columnLabel} > ${value}`;
+    case "isLessThanOrEqual":
+      return `${columnLabel} \u2264 ${value}`;
+    case "isGreaterThanOrEqual":
+      return `${columnLabel} \u2265 ${value}`;
+    case "isBetween":
+      return values ? `${columnLabel} between ${values[0]} and ${values[1]}` : `${columnLabel} is between`;
+    case "isNotBetween":
+      return values ? `${columnLabel} not between ${values[0]} and ${values[1]}` : `${columnLabel} is not between`;
+    case "isBefore":
+      return `${columnLabel} is before ${value}`;
+    case "isAfter":
+      return `${columnLabel} is after ${value}`;
+    case "isOnOrBefore":
+      return `${columnLabel} is on or before ${value}`;
+    case "isOnOrAfter":
+      return `${columnLabel} is on or after ${value}`;
+    case "isAnyOf":
+      return values ? `${columnLabel} is any of: ${values.join(", ")}` : `${columnLabel} is "${value}"`;
+    case "isNoneOf":
+      return values ? `${columnLabel} is none of: ${values.join(", ")}` : `${columnLabel} is not "${value}"`;
+    default:
+      return `${columnLabel} ${operator} ${value}`;
+  }
+}
+function createFilterPreset(name, filters, description) {
+  var now = /* @__PURE__ */new Date();
+  return {
+    id: `preset-${Date.now()}`,
+    name,
+    description,
+    filters: JSON.parse(JSON.stringify(filters)),
+    // Deep copy
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function serializeFilterPresets(presets) {
+  try {
+    return JSON.stringify(presets);
+  } catch (error) {
+    console.warn("Failed to serialize filter presets:", error);
+    return "[]";
+  }
+}
+function deserializeFilterPresets(presetString) {
+  try {
+    var parsed = JSON.parse(presetString);
+    return Array.isArray(parsed) ? parsed.map(function (preset) {
+      return {
+        ...preset,
+        createdAt: new Date(preset.createdAt),
+        updatedAt: new Date(preset.updatedAt)
+      };
+    }) : [];
+  } catch (error) {
+    console.warn("Failed to deserialize filter presets:", error);
+    return [];
+  }
+}
+//# sourceMappingURL=filterUtils.native.js.map

package/dist/jsx/utils/filterUtils.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__defProp","Object","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__hasOwnProp","prototype","hasOwnProperty","__export","target","all","name","get","enumerable","__copyProps","to","from","except","desc","key","call","__toCommonJS","mod","value","filterUtils_exports","applyFilterToValue","combineFilters","createFilterPreset","deserializeFilterPresets","deserializeFilters","generateFilterId","getFilterDescription","inferColumnType","serializeFilterPresets","serializeFilters","validateFilter","module","exports","_instanceof","left","right","Symbol","hasInstance","Date","now","Math","random","toString","slice","filters","JSON","stringify","error","console","warn","filterString","parsed","parse","Array","isArray","filterValue","columnType","arguments","length","operator","filterVal","values","stringValue","String","toLowerCase","filterStringValue","includes","startsWith","endsWith","Number","Boolean","numValue","min","max","numValue1","min1","max1","some","v","filter","_filter_value","errors","columnId","push","isValid","combinationMode","columnFilters","f","every","isNaN","columnLabel","label"],"sources":["../../../src/utils/filterUtils.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/jsx/utils/filterUtils.spec.mjs

@@ -0,0 +1,351 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { applyFilterToValue, deserializeFilters, generateFilterId, serializeFilters } from "./filterUtils.mjs";
+describe("filterUtils", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+  describe("generateFilterId", () => {
+    it("should generate unique filter IDs", () => {
+      const id1 = generateFilterId();
+      const id2 = generateFilterId();
+      expect(id1).toMatch(/^filter-\d+-[a-z0-9]+$/);
+      expect(id2).toMatch(/^filter-\d+-[a-z0-9]+$/);
+      expect(id1).not.toBe(id2);
+    });
+    it("should start with 'filter-'", () => {
+      const id = generateFilterId();
+      expect(id).toMatch(/^filter-/);
+    });
+  });
+  describe("serializeFilters", () => {
+    it("should serialize empty filter array", () => {
+      const result = serializeFilters([]);
+      expect(result).toBe("[]");
+    });
+    it("should serialize single filter", () => {
+      const filters = [{
+        id: "filter-1",
+        columnId: "name",
+        value: {
+          operator: "contains",
+          value: "test"
+        }
+      }];
+      const result = serializeFilters(filters);
+      expect(result).toContain("filter-1");
+      expect(result).toContain("name");
+      expect(result).toContain("contains");
+      expect(result).toContain("test");
+    });
+    it("should serialize multiple filters", () => {
+      const filters = [{
+        id: "filter-1",
+        columnId: "name",
+        value: {
+          operator: "contains",
+          value: "test"
+        }
+      }, {
+        id: "filter-2",
+        columnId: "age",
+        value: {
+          operator: "isGreaterThan",
+          value: 18
+        }
+      }];
+      const result = serializeFilters(filters);
+      const parsed = JSON.parse(result);
+      expect(parsed).toHaveLength(2);
+    });
+    it("should handle serialization errors gracefully", () => {
+      const circularRef = {
+        a: 1
+      };
+      circularRef.self = circularRef;
+      const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const result = serializeFilters([circularRef]);
+      expect(result).toBe("[]");
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+  });
+  describe("deserializeFilters", () => {
+    it("should deserialize empty array string", () => {
+      const result = deserializeFilters("[]");
+      expect(result).toEqual([]);
+    });
+    it("should deserialize single filter", () => {
+      const filterString = JSON.stringify([{
+        id: "filter-1",
+        columnId: "name",
+        value: {
+          operator: "contains",
+          value: "test"
+        }
+      }]);
+      const result = deserializeFilters(filterString);
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe("filter-1");
+      expect(result[0].columnId).toBe("name");
+    });
+    it("should handle invalid JSON", () => {
+      const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const result = deserializeFilters("invalid json");
+      expect(result).toEqual([]);
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+    it("should handle non-array JSON", () => {
+      const result = deserializeFilters('{"key":"value"}');
+      expect(result).toEqual([]);
+    });
+  });
+  describe("applyFilterToValue", () => {
+    describe("text filters", () => {
+      it("should apply 'contains' operator", () => {
+        const filterValue = {
+          operator: "contains",
+          value: "test"
+        };
+        expect(applyFilterToValue("this is a test", filterValue)).toBe(true);
+        expect(applyFilterToValue("no match", filterValue)).toBe(false);
+        expect(applyFilterToValue("TEST uppercase", filterValue)).toBe(true);
+      });
+      it("should apply 'doesNotContain' operator", () => {
+        const filterValue = {
+          operator: "doesNotContain",
+          value: "test"
+        };
+        expect(applyFilterToValue("no match", filterValue)).toBe(true);
+        expect(applyFilterToValue("this is a test", filterValue)).toBe(false);
+      });
+      it("should apply 'startsWith' operator", () => {
+        const filterValue = {
+          operator: "startsWith",
+          value: "hello"
+        };
+        expect(applyFilterToValue("hello world", filterValue)).toBe(true);
+        expect(applyFilterToValue("world hello", filterValue)).toBe(false);
+        expect(applyFilterToValue("HELLO WORLD", filterValue)).toBe(true);
+      });
+      it("should apply 'endsWith' operator", () => {
+        const filterValue = {
+          operator: "endsWith",
+          value: "world"
+        };
+        expect(applyFilterToValue("hello world", filterValue)).toBe(true);
+        expect(applyFilterToValue("world hello", filterValue)).toBe(false);
+      });
+      it("should apply 'isEmpty' operator", () => {
+        const filterValue = {
+          operator: "isEmpty",
+          value: ""
+        };
+        expect(applyFilterToValue("", filterValue)).toBe(true);
+        expect(applyFilterToValue(null, filterValue)).toBe(true);
+        expect(applyFilterToValue(void 0, filterValue)).toBe(true);
+        expect(applyFilterToValue("text", filterValue)).toBe(false);
+      });
+      it("should apply 'isNotEmpty' operator", () => {
+        const filterValue = {
+          operator: "isNotEmpty",
+          value: ""
+        };
+        expect(applyFilterToValue("text", filterValue)).toBe(true);
+        expect(applyFilterToValue("", filterValue)).toBe(false);
+        expect(applyFilterToValue(null, filterValue)).toBe(false);
+      });
+    });
+    describe("equality operators", () => {
+      it("should apply 'is' operator for text", () => {
+        const filterValue = {
+          operator: "is",
+          value: "test"
+        };
+        expect(applyFilterToValue("test", filterValue, "text")).toBe(true);
+        expect(applyFilterToValue("TEST", filterValue, "text")).toBe(true);
+        expect(applyFilterToValue("other", filterValue, "text")).toBe(false);
+      });
+      it("should apply 'is' operator for numbers", () => {
+        const filterValue = {
+          operator: "is",
+          value: 42
+        };
+        expect(applyFilterToValue(42, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue("42", filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(43, filterValue, "number")).toBe(false);
+      });
+      it("should apply 'is' operator for boolean", () => {
+        const filterValue = {
+          operator: "is",
+          value: true
+        };
+        expect(applyFilterToValue(true, filterValue, "boolean")).toBe(true);
+        expect(applyFilterToValue(false, filterValue, "boolean")).toBe(false);
+      });
+      it("should apply 'isNot' operator for text", () => {
+        const filterValue = {
+          operator: "isNot",
+          value: "test"
+        };
+        expect(applyFilterToValue("other", filterValue, "text")).toBe(true);
+        expect(applyFilterToValue("test", filterValue, "text")).toBe(false);
+      });
+      it("should apply 'isNot' operator for numbers", () => {
+        const filterValue = {
+          operator: "isNot",
+          value: 42
+        };
+        expect(applyFilterToValue(43, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(42, filterValue, "number")).toBe(false);
+      });
+    });
+    describe("null/undefined handling", () => {
+      it("should handle null values", () => {
+        const containsFilter = {
+          operator: "contains",
+          value: "test"
+        };
+        expect(applyFilterToValue(null, containsFilter)).toBe(false);
+        const emptyFilter = {
+          operator: "isEmpty",
+          value: ""
+        };
+        expect(applyFilterToValue(null, emptyFilter)).toBe(true);
+      });
+      it("should handle undefined values", () => {
+        const containsFilter = {
+          operator: "contains",
+          value: "test"
+        };
+        expect(applyFilterToValue(void 0, containsFilter)).toBe(false);
+        const emptyFilter = {
+          operator: "isEmpty",
+          value: ""
+        };
+        expect(applyFilterToValue(void 0, emptyFilter)).toBe(true);
+      });
+    });
+    describe("number filters", () => {
+      it("should apply 'isLessThan' operator", () => {
+        const filterValue = {
+          operator: "isLessThan",
+          value: 100
+        };
+        expect(applyFilterToValue(50, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(100, filterValue, "number")).toBe(false);
+        expect(applyFilterToValue(150, filterValue, "number")).toBe(false);
+      });
+      it("should apply 'isGreaterThan' operator", () => {
+        const filterValue = {
+          operator: "isGreaterThan",
+          value: 100
+        };
+        expect(applyFilterToValue(150, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(100, filterValue, "number")).toBe(false);
+        expect(applyFilterToValue(50, filterValue, "number")).toBe(false);
+      });
+      it("should apply 'isLessThanOrEqual' operator", () => {
+        const filterValue = {
+          operator: "isLessThanOrEqual",
+          value: 100
+        };
+        expect(applyFilterToValue(50, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(100, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(150, filterValue, "number")).toBe(false);
+      });
+      it("should apply 'isGreaterThanOrEqual' operator", () => {
+        const filterValue = {
+          operator: "isGreaterThanOrEqual",
+          value: 100
+        };
+        expect(applyFilterToValue(150, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(100, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(50, filterValue, "number")).toBe(false);
+      });
+      it("should apply 'isBetween' operator", () => {
+        const filterValue = {
+          operator: "isBetween",
+          value: 50,
+          values: [50, 150]
+        };
+        expect(applyFilterToValue(100, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(50, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(150, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(25, filterValue, "number")).toBe(false);
+        expect(applyFilterToValue(200, filterValue, "number")).toBe(false);
+      });
+      it("should apply 'isNotBetween' operator", () => {
+        const filterValue = {
+          operator: "isNotBetween",
+          value: 50,
+          values: [50, 150]
+        };
+        expect(applyFilterToValue(25, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(200, filterValue, "number")).toBe(true);
+        expect(applyFilterToValue(100, filterValue, "number")).toBe(false);
+      });
+    });
+    describe("date filters", () => {
+      const testDate = (/* @__PURE__ */new Date("2024-06-15")).getTime();
+      const earlierDate = (/* @__PURE__ */new Date("2024-01-01")).getTime();
+      const laterDate = (/* @__PURE__ */new Date("2024-12-31")).getTime();
+      it("should apply 'isBefore' operator", () => {
+        const filterValue = {
+          operator: "isBefore",
+          value: testDate
+        };
+        expect(applyFilterToValue(earlierDate, filterValue, "date")).toBe(true);
+        expect(applyFilterToValue(laterDate, filterValue, "date")).toBe(false);
+      });
+      it("should apply 'isAfter' operator", () => {
+        const filterValue = {
+          operator: "isAfter",
+          value: testDate
+        };
+        expect(applyFilterToValue(laterDate, filterValue, "date")).toBe(true);
+        expect(applyFilterToValue(earlierDate, filterValue, "date")).toBe(false);
+      });
+      it("should apply 'isOnOrBefore' operator", () => {
+        const filterValue = {
+          operator: "isOnOrBefore",
+          value: testDate
+        };
+        expect(applyFilterToValue(earlierDate, filterValue, "date")).toBe(true);
+        expect(applyFilterToValue(testDate, filterValue, "date")).toBe(true);
+        expect(applyFilterToValue(laterDate, filterValue, "date")).toBe(false);
+      });
+      it("should apply 'isOnOrAfter' operator", () => {
+        const filterValue = {
+          operator: "isOnOrAfter",
+          value: testDate
+        };
+        expect(applyFilterToValue(laterDate, filterValue, "date")).toBe(true);
+        expect(applyFilterToValue(testDate, filterValue, "date")).toBe(true);
+        expect(applyFilterToValue(earlierDate, filterValue, "date")).toBe(false);
+      });
+    });
+    describe("option filters", () => {
+      it("should apply 'isAnyOf' operator", () => {
+        const filterValue = {
+          operator: "isAnyOf",
+          value: "",
+          values: ["red", "blue", "green"]
+        };
+        expect(applyFilterToValue("red", filterValue)).toBe(true);
+        expect(applyFilterToValue("blue", filterValue)).toBe(true);
+        expect(applyFilterToValue("yellow", filterValue)).toBe(false);
+      });
+      it("should apply 'isNoneOf' operator", () => {
+        const filterValue = {
+          operator: "isNoneOf",
+          value: "",
+          values: ["red", "blue", "green"]
+        };
+        expect(applyFilterToValue("yellow", filterValue)).toBe(true);
+        expect(applyFilterToValue("red", filterValue)).toBe(false);
+      });
+    });
+  });
+});
+//# sourceMappingURL=filterUtils.spec.mjs.map