impact-nova 1.7.39 → 1.7.40

package/dist/components/ui/ag-grid-react/headers/utils/filter-utils.js

@@ -1,4 +1,4 @@
-import { getTodayStr as M, getYesterdayStr as F, getMonthRange as S, getYearRange as W } from "./date-utils.js";
+import { DEFAULT_DATE_DISPLAY_FORMAT as O, isoToDisplay as S, getTodayStr as b, getYesterdayStr as W, getMonthRange as F, getYearRange as x } from "./date-utils.js";
 const v = {
   yes: !0,
   true: !0,
@@ -11,7 +11,7 @@ const v = {
   "[ ]": !1,
   inactive: !1,
   disabled: !1
-}, C = {
+}, $ = {
   jan: 1,
   january: 1,
   feb: 2,
@@ -36,145 +36,146 @@ const v = {
   dec: 12,
   december: 12
 };
-function w(a) {
-  const t = a?.filterParams?.filters || [];
+function L(i) {
+  const n = i?.filterParams?.filters || [];
   return {
-    text: t.findIndex((n) => (typeof n == "string" ? n : n.filter) === "agTextColumnFilter"),
-    number: t.findIndex((n) => (typeof n == "string" ? n : n.filter) === "agNumberColumnFilter"),
-    set: t.findIndex((n) => (typeof n == "string" ? n : n.filter) === "agSetColumnFilter"),
-    date: t.findIndex((n) => (typeof n == "string" ? n : n.filter) === "agDateColumnFilter")
+    text: n.findIndex((e) => (typeof e == "string" ? e : e.filter) === "agTextColumnFilter"),
+    number: n.findIndex((e) => (typeof e == "string" ? e : e.filter) === "agNumberColumnFilter"),
+    set: n.findIndex((e) => (typeof e == "string" ? e : e.filter) === "agSetColumnFilter"),
+    date: n.findIndex((e) => (typeof e == "string" ? e : e.filter) === "agDateColumnFilter")
   };
 }
-function d(a) {
-  const t = a.toLowerCase().trim();
-  return t === "today" ? M() : t === "yesterday" ? F() : a;
+function g(i) {
+  const n = i.toLowerCase().trim();
+  return n === "today" ? b() : n === "yesterday" ? W() : i;
 }
-function q(a, t = !1, n = !1) {
-  const r = a.trim();
-  if (!r)
+function E(i, n = !1, e = !1) {
+  const t = i.trim();
+  if (!t)
     return { operator: "contains", value: "" };
-  if (r === '""') return { operator: "empty", value: "" };
-  if (r === '!""') return { operator: "notEmpty", value: "" };
-  if (r.startsWith("!="))
-    return { operator: "notEqual", value: d(r.slice(2)) };
-  if (r.startsWith("=="))
-    return { operator: "equals", value: d(r.slice(2)) };
-  if (r.startsWith("=")) {
-    const e = r.slice(1).trim(), l = e.toLowerCase();
-    return v[l] !== void 0 ? { operator: "equals", value: String(v[l]) } : { operator: "equals", value: d(e) };
+  if (t === '""') return { operator: "empty", value: "" };
+  if (t === '!""') return { operator: "notEmpty", value: "" };
+  if (t.startsWith("!="))
+    return { operator: "notEqual", value: g(t.slice(2)) };
+  if (t.startsWith("=="))
+    return { operator: "equals", value: g(t.slice(2)) };
+  if (t.startsWith("=")) {
+    const o = t.slice(1).trim(), r = o.toLowerCase();
+    return v[r] !== void 0 ? { operator: "equals", value: String(v[r]) } : { operator: "equals", value: g(o) };
   }
-  if (r.startsWith("!"))
-    return { operator: "notContains", value: d(r.slice(1)) };
-  if (r.startsWith(">="))
-    return { operator: "greaterThanOrEqual", value: d(r.slice(2)) };
-  if (r.startsWith(">"))
-    return { operator: "greaterThan", value: d(r.slice(1)) };
-  if (r.startsWith("<="))
-    return { operator: "lessThanOrEqual", value: d(r.slice(2)) };
-  if (r.startsWith("<"))
-    return { operator: "lessThan", value: d(r.slice(1)) };
-  if (r.startsWith("*") && r.length > 1 && !r.endsWith("*"))
-    return { operator: "endsWith", value: r.slice(1).trim() };
-  if (r.endsWith("*") && r.length > 1 && !r.startsWith("*"))
-    return { operator: "startsWith", value: r.slice(0, -1).trim() };
-  const i = r.match(/^(\d+(?:\.\d+)?)\s*-\s*(\d+(?:\.\d+)?)$/);
-  if (i)
-    return { operator: "inRange", value: i[1], valueTo: i[2] };
-  const f = r.match(/^(\d{4}-\d{2}-\d{2})\s*-\s*(\d{4}-\d{2}-\d{2})$/);
-  if (f)
-    return { operator: "inRange", value: f[1], valueTo: f[2] };
-  const c = r.toLowerCase();
-  if (t && v[c] !== void 0)
-    return { operator: "equals", value: String(v[c]) };
-  if (n) {
-    if (c === "today") return { operator: "equals", value: M() };
-    if (c === "yesterday") return { operator: "equals", value: F() };
-    if (/^\d{4}$/.test(r)) {
-      const l = W(Number(r));
-      return { operator: "inRange", value: l.from, valueTo: l.to };
+  if (t.startsWith("!"))
+    return { operator: "notContains", value: g(t.slice(1)) };
+  if (t.startsWith(">="))
+    return { operator: "greaterThanOrEqual", value: g(t.slice(2)) };
+  if (t.startsWith(">"))
+    return { operator: "greaterThan", value: g(t.slice(1)) };
+  if (t.startsWith("<="))
+    return { operator: "lessThanOrEqual", value: g(t.slice(2)) };
+  if (t.startsWith("<"))
+    return { operator: "lessThan", value: g(t.slice(1)) };
+  if (t.startsWith("*") && t.length > 1 && !t.endsWith("*"))
+    return { operator: "endsWith", value: t.slice(1).trim() };
+  if (t.endsWith("*") && t.length > 1 && !t.startsWith("*"))
+    return { operator: "startsWith", value: t.slice(0, -1).trim() };
+  const s = t.match(/^(\d+(?:\.\d+)?)\s*~\s*(\d+(?:\.\d+)?)$/);
+  if (s)
+    return { operator: "inRange", value: s[1], valueTo: s[2] };
+  const c = t.match(/^(\d{4}-\d{2}-\d{2})\s*~\s*(\d{4}-\d{2}-\d{2})$/);
+  if (c)
+    return { operator: "inRange", value: c[1], valueTo: c[2] };
+  const p = t.match(/^([^~]+)~([^~]+)$/);
+  if (p) {
+    const o = p[1].trim(), r = p[2].trim();
+    if (/\d/.test(o) && /\d/.test(r))
+      return { operator: "inRange", value: o, valueTo: r };
+  }
+  const a = t.toLowerCase();
+  if (n && v[a] !== void 0)
+    return { operator: "equals", value: String(v[a]) };
+  if (e) {
+    if (a === "today") return { operator: "equals", value: b() };
+    if (a === "yesterday") return { operator: "equals", value: W() };
+    if (/^\d{4}$/.test(t)) {
+      const r = x(Number(t));
+      return { operator: "inRange", value: r.from, valueTo: r.to };
     }
-    const e = r.match(/^([a-zA-Z]+)\s*(\d{4})$/);
-    if (e) {
-      const l = C[e[1].toLowerCase()];
-      if (l) {
-        const u = S(l, Number(e[2]));
+    const o = t.match(/^([a-zA-Z]+)\s*(\d{4})$/);
+    if (o) {
+      const r = $[o[1].toLowerCase()];
+      if (r) {
+        const u = F(r, Number(o[2]));
         return { operator: "inRange", value: u.from, valueTo: u.to };
       }
     }
   }
-  return { operator: "contains", value: r };
+  return { operator: "contains", value: t };
 }
-function I(a, t = !1, n = !1, r = !1) {
-  if (!a || a.trim() === "")
+function w(i, n = !1, e = !1, t = !1) {
+  if (!i || i.trim() === "")
     return { conditions: [], logic: "OR" };
-  const i = a.trim();
-  if (i === "*")
+  const s = i.trim();
+  if (s === "*")
     return { conditions: [], logic: "OR", matchAll: !0 };
-  const f = i.includes("+") || i.includes("&"), c = i.includes(",") || i.includes(";");
-  if (f)
-    return { conditions: i.split(/\s*[+&]\s*/).filter((o) => !!o.trim()).map((o) => q(o, n, r)).filter((o) => !!o.value), logic: "AND" };
+  const c = s.includes("+") || s.includes("&"), p = s.includes(",") || s.includes(";");
   if (c)
-    return { conditions: i.split(/\s*[,;]\s*/).filter((o) => !!o.trim()).map((o) => q(o, n, r)).filter((o) => !!o.value), logic: "OR" };
-  if (t) {
-    const l = i.split(/\s+/).filter((u) => !!u.trim());
-    if (l.length > 1) {
-      const u = l.map((o) => q(o, n, r)).filter((o) => !!o.value);
-      if (u.length > 1)
-        return { conditions: u, logic: "OR" };
+    return { conditions: s.split(/\s*[+&]\s*/).filter((u) => !!u.trim()).map((u) => E(u, e, t)).filter((u) => !!u.value), logic: "AND" };
+  if (p)
+    return { conditions: s.split(/\s*[,;]\s*/).filter((u) => !!u.trim()).map((u) => E(u, e, t)).filter((u) => !!u.value), logic: "OR" };
+  if (n) {
+    const o = s.split(/\s+/).filter((r) => !!r.trim());
+    if (o.length > 1) {
+      const r = o.map((u) => E(u, e, t)).filter((u) => !!u.value);
+      if (r.length > 1)
+        return { conditions: r, logic: "OR" };
     }
   }
-  const e = q(i, n, r);
-  return !e.value && e.operator === "contains" ? { conditions: [], logic: "OR" } : { conditions: [e], logic: "OR" };
+  const a = E(s, e, t);
+  return !a.value && a.operator === "contains" ? { conditions: [], logic: "OR" } : { conditions: [a], logic: "OR" };
 }
-function m(a) {
-  if (!a) return "";
-  if (Array.isArray(a))
-    return a.map((t) => m(t)).join(", ");
-  if (/^\d{4}-\d{2}-\d{2}/.test(a))
-    try {
-      const t = new Date(a);
-      if (!isNaN(t.getTime())) {
-        const n = String(t.getMonth() + 1).padStart(2, "0"), r = String(t.getDate()).padStart(2, "0");
-        return `${n}/${r}`;
-      }
-    } catch {
-    }
-  return a;
+function m(i, n = O) {
+  if (!i) return "";
+  if (Array.isArray(i))
+    return i.map((e) => m(e, n)).join(", ");
+  if (/^\d{4}-\d{2}-\d{2}/.test(i)) {
+    const e = S(i, n);
+    if (e) return e;
+  }
+  return i;
 }
-function $(a) {
-  const t = m(a.value), n = m(a.valueTo || "");
-  switch (a.operator) {
+function N(i, n = O) {
+  const e = m(i.value, n), t = m(i.valueTo || "", n);
+  switch (i.operator) {
     case "contains":
-      return t;
+      return e;
     case "notContains":
-      return `!${t}`;
+      return `!${e}`;
     case "equals":
-      return a.columnType === "number" || a.columnType === "date" || a.columnType === "select" ? t : `=${t}`;
+      return i.columnType === "number" || i.columnType === "date" || i.columnType === "select" ? e : `=${e}`;
     case "notEqual":
-      return `!=${t}`;
+      return `!=${e}`;
     case "startsWith":
-      return `${t}*`;
+      return `${e}*`;
     case "endsWith":
-      return `*${t}`;
+      return `*${e}`;
     case "greaterThan":
-      return `>${t}`;
+      return `>${e}`;
     case "greaterThanOrEqual":
-      return `≥${t}`;
+      return `>=${e}`;
     case "lessThan":
-      return `<${t}`;
+      return `<${e}`;
     case "lessThanOrEqual":
-      return `≤${t}`;
+      return `<=${e}`;
     case "inRange":
-      return `${t}–${n}`;
+      return `${e}~${t}`;
     case "empty":
       return "∅";
     case "notEmpty":
       return "≠∅";
     default:
-      return t;
+      return e;
   }
 }
-const b = {
+const C = {
   contains: "contains",
   notContains: "notContains",
   equals: "equals",
@@ -196,47 +197,47 @@ const b = {
   lt: "lessThan",
   lte: "lessThanOrEqual"
 };
-function O(a, t) {
-  if (!t) return "";
-  if ("filterType" in t && t.filterType === "multi" && t.filterModels)
-    return t.filterModels.map((r) => O(a, r)).filter((r) => !!r).join(", ");
-  if ("filterType" in t && t.filterType === "set" && t.values) {
-    const i = t.values || [];
-    return i.length === 0 ? "" : i.length === 1 ? m(i[0]) : `${m(i[0])} (+${i.length - 1})`;
+function A(i, n, e = O) {
+  if (!n) return "";
+  if ("filterType" in n && n.filterType === "multi" && n.filterModels)
+    return n.filterModels.map((s) => A(i, s, e)).filter((s) => !!s).join(", ");
+  if ("filterType" in n && n.filterType === "set" && n.values) {
+    const c = n.values || [];
+    return c.length === 0 ? "" : c.length === 1 ? m(c[0]) : `${m(c[0])} (+${c.length - 1})`;
   }
-  if ("conditions" in t && t.conditions && t.operator) {
-    const r = t.operator === "AND" ? " + " : ", ";
-    return t.conditions.map((i) => O(a, i)).filter((i) => !!i).join(r);
+  if ("conditions" in n && n.conditions && n.operator) {
+    const s = n.operator === "AND" ? " + " : ", ";
+    return n.conditions.map((c) => A(i, c, e)).filter((c) => !!c).join(s);
   }
-  const n = t;
-  if ("type" in n && n.type) {
-    const r = n.type, i = b[r] || r, f = n.filter !== void 0 ? String(n.filter) : n.dateFrom !== void 0 ? String(n.dateFrom) : "", c = n.filterTo !== void 0 ? String(n.filterTo) : n.dateTo !== void 0 ? String(n.dateTo) : void 0;
-    return $({
-      operator: i,
-      value: f,
-      valueTo: c,
+  const t = n;
+  if ("type" in t && t.type) {
+    const s = t.type, c = C[s] || s, p = t.filter !== void 0 ? String(t.filter) : t.dateFrom !== void 0 ? String(t.dateFrom) : "", a = t.filterTo !== void 0 ? String(t.filterTo) : t.dateTo !== void 0 ? String(t.dateTo) : void 0;
+    return N({
+      operator: c,
+      value: p,
+      valueTo: a,
       // Optimization: determine type roughly for '=' vs contains logic
-      columnType: n.filterType === "number" ? "number" : n.filterType === "date" ? "date" : "text"
-    });
+      columnType: t.filterType === "number" ? "number" : t.filterType === "date" ? "date" : "text"
+    }, e);
   }
   return "";
 }
-function A() {
+function R() {
   return Math.random().toString(36).substring(2, 11);
 }
-function j(a = "", t) {
-  const n = t === "number" || t === "date" || t === "select" ? "equals" : "contains";
+function D(i = "", n) {
+  const e = n === "number" || n === "date" || n === "select" ? "equals" : "contains";
   return {
-    id: A(),
-    columnId: a,
-    operator: n,
+    id: R(),
+    columnId: i,
+    operator: e,
     value: "",
-    columnType: t
+    columnType: n
     // Store for proper filterType in AG Grid conversion
   };
 }
-function h(a) {
-  switch (a) {
+function h(i) {
+  switch (i) {
     case "contains":
       return "contains";
     case "notContains":
@@ -267,185 +268,208 @@ function h(a) {
       return "contains";
   }
 }
-function R(a, t, n) {
-  return n === "number" ? "number" : n === "date" ? "date" : n === "select" || n === "set" || Array.isArray(t) ? a === "notEqual" || a === "notContains" ? "text" : "set" : typeof t == "string" && /^\d{4}-\d{2}-\d{2}/.test(t) ? "date" : ["greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual", "inRange"].includes(a) && t && !x(t) && !isNaN(Number(t)) || typeof t == "string" && t && /^-?\d+(\.\d+)?$/.test(t.trim()) ? "number" : "text";
+function M(i, n, e) {
+  return e === "number" ? "number" : e === "date" ? "date" : e === "select" || e === "set" || Array.isArray(n) ? i === "notEqual" || i === "notContains" ? "text" : "set" : typeof n == "string" && /^\d{4}-\d{2}-\d{2}/.test(n) ? "date" : ["greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual", "inRange"].includes(i) && n && !I(n) && !isNaN(Number(n)) || typeof n == "string" && n && /^-?\d+(\.\d+)?$/.test(n.trim()) ? "number" : "text";
 }
-function x(a) {
-  return Array.isArray(a);
+function I(i) {
+  return Array.isArray(i);
 }
-function D(a) {
-  if (console.log("[AdvancedFilter] convertToAgGridFilterModel input:", a), !a || !a.rules || a.rules.length === 0)
-    return console.log("[AdvancedFilter] No model or empty rules, returning empty"), {};
-  const t = {}, n = {}, r = (i) => {
-    "logic" in i ? (i.conditions || []).forEach(r) : i.columnId && (i.value || i.operator === "empty" || i.operator === "notEmpty") && (n[i.columnId] || (n[i.columnId] = []), n[i.columnId].push(i));
+function k(i) {
+  if (!i || !i.rules || i.rules.length === 0)
+    return {};
+  const n = {}, e = {}, t = (s) => {
+    "logic" in s ? (s.conditions || []).forEach(t) : s.columnId && (s.value || s.operator === "empty" || s.operator === "notEmpty") && (e[s.columnId] || (e[s.columnId] = []), e[s.columnId].push(s));
   };
-  a.rules.forEach(r), console.log("[AdvancedFilter] Rules by column:", n);
-  for (const [i, f] of Object.entries(n)) {
-    if (f.length === 0) continue;
-    if (f[0].columnType === "multi") {
-      const e = (s) => s.operator !== "equals" ? !1 : !!(Array.isArray(s.value) || ["select", "multi"].includes(s.columnType)), l = f.filter(e), u = f.filter((s) => !e(s)), o = [null, null];
+  i.rules.forEach(t);
+  for (const [s, c] of Object.entries(e)) {
+    if (c.length === 0) continue;
+    const p = i.columnLogic?.[s] || i.logic;
+    if (c[0].columnType === "multi") {
+      const o = (f) => f.operator !== "equals" ? !1 : !!(Array.isArray(f.value) || ["select", "multi"].includes(f.columnType)), r = c.filter(o), u = c.filter((f) => !o(f)), l = [null, null];
       if (u.length > 0) {
-        const s = E(u, "text", a.logic);
-        s && (o[0] = s);
+        const f = q(u, "text", p);
+        f && (l[0] = f);
       }
-      if (l.length > 0) {
-        const s = E(l, "set", a.logic);
-        s && (o[1] = s);
+      if (r.length > 0) {
+        const f = q(r, "set", p);
+        f && (l[1] = f);
       }
-      (o[0] || o[1]) && (t[i] = {
+      (l[0] || l[1]) && (n[s] = {
         filterType: "multi",
-        filterModels: o
+        filterModels: l
       });
     } else {
-      const e = E(f, f[0].columnType, a.logic);
-      e && (t[i] = e);
+      const o = q(c, c[0].columnType, p);
+      o && (n[s] = o);
     }
   }
-  return console.log("[AdvancedFilter] Converted AG Grid filter model:", t), t;
+  return n;
 }
-function E(a, t, n = "OR") {
-  if (a.length === 0) return null;
-  const r = [];
-  a.forEach((e) => {
-    Array.isArray(e.value) && (e.operator === "notEqual" || e.operator === "notContains") ? e.value.forEach((l) => {
-      r.push({
-        ...e,
-        value: l,
-        id: A()
+function q(i, n, e = "OR") {
+  if (i.length === 0) return null;
+  const t = [];
+  i.forEach((a) => {
+    Array.isArray(a.value) && (a.operator === "notEqual" || a.operator === "notContains") ? a.value.forEach((o) => {
+      t.push({
+        ...a,
+        value: o,
+        id: R()
         // Unique ID for each condition
       });
-    }) : r.push(e);
+    }) : t.push(a);
   });
-  const i = r.some((e) => e.operator === "notEqual" || e.operator === "notContains");
-  if (t === "set" || r.some((e) => Array.isArray(e.value) || e.columnType === "select") && !i) {
-    const e = /* @__PURE__ */ new Set();
-    return r.forEach((l) => {
-      Array.isArray(l.value) ? l.value.forEach((u) => e.add(u)) : l.value && e.add(l.value);
+  const s = t.some((a) => a.operator === "notEqual" || a.operator === "notContains");
+  if (n === "set" || t.some((a) => Array.isArray(a.value) || a.columnType === "select") && !s) {
+    const a = /* @__PURE__ */ new Set();
+    return t.forEach((o) => {
+      Array.isArray(o.value) ? o.value.forEach((r) => a.add(r)) : o.value && a.add(o.value);
     }), {
       filterType: "set",
-      values: Array.from(e)
+      values: Array.from(a)
     };
   }
-  const c = r;
-  if (c.length === 1) {
-    const e = c[0], l = R(e.operator, e.value, e.columnType);
-    if (l === "date" && typeof e.value == "string") {
-      const o = (s) => {
-        if (!s || Array.isArray(s)) return null;
-        if (/^\d{4}-\d{2}-\d{2}$/.test(s)) return s;
+  const p = t;
+  if (p.length === 1) {
+    const a = p[0], o = M(a.operator, a.value, a.columnType);
+    if (o === "date" && typeof a.value == "string") {
+      const u = (l) => {
+        if (!l || Array.isArray(l)) return null;
+        if (/^\d{4}-\d{2}-\d{2}$/.test(l)) return l;
         try {
-          const p = new Date(s), y = p.getFullYear(), g = String(p.getMonth() + 1).padStart(2, "0"), T = String(p.getDate()).padStart(2, "0");
-          return `${y}-${g}-${T}`;
+          const f = new Date(l), d = f.getFullYear(), y = String(f.getMonth() + 1).padStart(2, "0"), T = String(f.getDate()).padStart(2, "0");
+          return `${d}-${y}-${T}`;
         } catch {
-          return s;
+          return l;
         }
       };
-      return e.operator === "inRange" ? {
+      return a.operator === "inRange" ? {
         type: "inRange",
-        dateFrom: o(e.value),
-        dateTo: o(e.valueTo || ""),
+        dateFrom: u(a.value),
+        dateTo: u(a.valueTo || ""),
         filterType: "date"
       } : {
-        type: h(e.operator),
-        dateFrom: o(e.value),
+        type: h(a.operator),
+        dateFrom: u(a.value),
         filterType: "date"
       };
     }
-    const u = (o) => {
-      if (Array.isArray(o)) return o;
-      const s = e.columnType === "number";
-      if (l === "number" || s) {
-        const p = parseFloat(o);
-        return isNaN(p) ? o : p;
+    const r = (u) => {
+      if (Array.isArray(u)) return u;
+      const l = a.columnType === "number";
+      if (o === "number" || l) {
+        const f = parseFloat(u);
+        return isNaN(f) ? u : f;
       }
-      return o;
+      return u;
     };
-    return e.operator === "inRange" ? {
-      type: h(e.operator),
-      filter: u(e.value),
-      filterTo: u(e.valueTo || ""),
-      filterType: l
-    } : e.operator === "empty" || e.operator === "notEmpty" ? {
-      type: h(e.operator),
+    return a.operator === "inRange" ? {
+      type: h(a.operator),
+      filter: r(a.value),
+      filterTo: r(a.valueTo || ""),
+      filterType: o
+    } : a.operator === "empty" || a.operator === "notEmpty" ? {
+      type: h(a.operator),
       filterType: "text"
       // Empty checks usually run on text filter or generic
     } : {
-      type: h(e.operator),
-      filter: u(e.value),
-      filterType: l
+      type: h(a.operator),
+      filter: r(a.value),
+      filterType: o
     };
   } else {
-    let e = "text";
-    const l = a.map((u) => {
-      const o = h(u.operator), s = R(u.operator, u.value, u.columnType);
-      e === "text" && s !== "text" && s !== "set" && (e = s);
-      const p = (g) => {
-        if (Array.isArray(g)) return g;
-        if (s === "number") {
-          const T = parseFloat(g);
-          return isNaN(T) ? g : T;
+    let a = "text";
+    const o = i.map((r) => {
+      const u = h(r.operator), l = M(r.operator, r.value, r.columnType);
+      a === "text" && l !== "text" && l !== "set" && (a = l);
+      const f = (y) => {
+        if (Array.isArray(y)) return y;
+        if (l === "number") {
+          const T = parseFloat(y);
+          return isNaN(T) ? y : T;
         }
-        return g;
+        return y;
       };
-      let y = o;
-      return s === "number" && (["contains", "startsWith", "endsWith"].includes(o) ? y = "equals" : o === "notContains" && (y = "notEqual")), u.operator === "inRange" ? {
-        type: o,
-        filter: p(u.value),
-        filterTo: p(u.valueTo || ""),
-        filterType: s
-      } : u.operator === "empty" || u.operator === "notEmpty" ? {
-        type: o,
+      let d = u;
+      return l === "number" && (["contains", "startsWith", "endsWith"].includes(u) ? d = "equals" : u === "notContains" && (d = "notEqual")), r.operator === "inRange" ? l === "date" ? {
+        type: "inRange",
+        dateFrom: r.value,
+        dateTo: r.valueTo || "",
+        filterType: "date"
+      } : {
+        type: u,
+        filter: f(r.value),
+        filterTo: f(r.valueTo || ""),
+        filterType: l
+      } : r.operator === "empty" || r.operator === "notEmpty" ? {
+        type: u,
         filterType: "text"
+      } : l === "date" && typeof r.value == "string" ? {
+        type: d,
+        dateFrom: r.value,
+        filterType: "date"
       } : {
-        type: y,
-        filter: p(u.value),
-        filterType: s
+        type: d,
+        filter: f(r.value),
+        filterType: l
       };
     });
     return {
-      filterType: e,
-      operator: n,
-      conditions: l
+      filterType: a,
+      operator: e,
+      conditions: o
     };
   }
 }
-function k(a) {
-  if (!a || Object.keys(a).length === 0) return null;
-  const t = [];
-  for (const [n, r] of Object.entries(a)) {
-    if (!r) continue;
-    const i = (c) => {
-      if (!c) return [];
-      if ("conditions" in c && c.conditions && c.operator)
-        return c.conditions.flatMap((s) => i(s));
-      if ("filterType" in c && c.filterType === "multi" && c.filterModels)
-        return c.filterModels.flatMap((s) => s ? i(s) : []);
-      const e = c, l = "type" in e ? e.type : "equals", u = e.filterType === "set" ? "equals" : b[l] || "contains", o = e.filter !== void 0 ? String(e.filter) : e.dateFrom !== void 0 ? String(e.dateFrom) : e.values ? e.values : "";
+function _(i) {
+  if (!i || Object.keys(i).length === 0) return null;
+  const n = [], e = {};
+  for (const [t, s] of Object.entries(i)) {
+    if (!s) continue;
+    ((o) => {
+      const r = o;
+      if (r.conditions && r.operator && (e[t] = r.operator), "filterType" in o && o.filterType === "multi" && o.filterModels)
+        for (const u of o.filterModels) {
+          if (!u) continue;
+          const l = u;
+          if (l.conditions && l.operator) {
+            e[t] = l.operator;
+            break;
+          }
+        }
+    })(s);
+    const p = (o) => {
+      if (!o) return [];
+      if ("conditions" in o && o.conditions && o.operator)
+        return o.conditions.flatMap((d) => p(d));
+      if ("filterType" in o && o.filterType === "multi" && o.filterModels)
+        return o.filterModels.flatMap((d) => d ? p(d) : []);
+      const r = o, u = "type" in r ? r.type : "equals", l = r.filterType === "set" ? "equals" : C[u] || "contains", f = r.filter !== void 0 ? String(r.filter) : r.dateFrom !== void 0 ? String(r.dateFrom) : r.values ? r.values : "";
       return [{
-        id: A(),
-        columnId: n,
-        operator: u,
-        value: o,
-        valueTo: e.filterTo || e.dateTo,
-        columnType: e.filterType
+        id: R(),
+        columnId: t,
+        operator: l,
+        value: f,
+        valueTo: r.filterTo || r.dateTo,
+        columnType: r.filterType
       }];
-    }, f = i(r);
-    t.push(...f);
+    }, a = p(s);
+    n.push(...a);
   }
-  return t.length === 0 ? null : {
-    logic: "AND",
-    // Default top-level logic
-    rules: t
+  return n.length === 0 ? null : {
+    logic: "OR",
+    rules: n,
+    columnLogic: Object.keys(e).length > 0 ? e : void 0
   };
 }
 export {
-  k as convertFromAgGridFilterModel,
-  D as convertToAgGridFilterModel,
-  j as createEmptyRule,
-  $ as formatRuleForDisplay,
-  A as generateFilterId,
-  O as getDisplayStringFromFilterModel,
-  w as getMultiFilterIndices,
+  C as agToInternalOperator,
+  _ as convertFromAgGridFilterModel,
+  k as convertToAgGridFilterModel,
+  D as createEmptyRule,
+  N as formatRuleForDisplay,
+  R as generateFilterId,
+  A as getDisplayStringFromFilterModel,
+  L as getMultiFilterIndices,
   h as mapOperatorToAgGrid,
-  I as parseInputPattern
+  w as parseInputPattern
 };