@open-mercato/shared 0.6.1-develop.3276.1.1fcd145078 → 0.6.1-develop.3278.1.a4d26475e4

package/.turbo/turbo-build.log

@@ -1,2 +1,2 @@
-[build:shared] found 203 entry points
+[build:shared] found 204 entry points
 [build:shared] built successfully

package/dist/lib/crud/advanced-filter-integration.js

@@ -1,4 +1,10 @@
-import { deserializeAdvancedFilter, convertAdvancedFilterToWhere } from "../query/advanced-filter.js";
+import {
+  deserializeAdvancedFilter,
+  deserializeTree,
+  flatToTree,
+  convertAdvancedFilterToWhere
+} from "../query/advanced-filter.js";
+import { compileTreeToWhere } from "../query/advanced-filter-tree.js";
 function splitOrClauses(filters) {
   const directFilters = {};
   let orClauses = null;
@@ -45,7 +51,47 @@ function mergeAdvancedFilters(existingFilters, query) {
   }
   return { ...existingFilters, ...advancedWhere };
 }
+function mergeAdvancedFilterTree(routeFilters, tree) {
+  if (!tree) return routeFilters;
+  const treeWhere = compileTreeToWhere(tree);
+  if (!treeWhere) return routeFilters;
+  if (Object.keys(routeFilters).length === 0) return treeWhere;
+  return { $and: [routeFilters, treeWhere] };
+}
+function mergeAdvancedFiltersFromQuery(routeFilters, query) {
+  const v2 = deserializeTree(query);
+  if (v2) return mergeAdvancedFilterTree(routeFilters, v2);
+  const flat = deserializeAdvancedFilter(query);
+  if (!flat) return routeFilters;
+  return mergeAdvancedFilterTree(routeFilters, flatToTree(flat));
+}
+function consumeAdvancedFilterState(query) {
+  let tree = deserializeTree(query);
+  if (!tree) {
+    const flat = deserializeAdvancedFilter(query);
+    if (flat) {
+      tree = flatToTree(flat);
+      if (process.env.NODE_ENV !== "production") {
+        const sentinel = "__OM_FILTER_V1_WARNED";
+        const g = globalThis;
+        if (!g[sentinel]) {
+          g[sentinel] = true;
+          console.warn("[advanced-filter] legacy v1 URL detected; auto-upgraded to v2 tree");
+        }
+      }
+    }
+  }
+  for (const key of Object.keys(query)) {
+    if (key.startsWith("filter[")) {
+      delete query[key];
+    }
+  }
+  return tree;
+}
 export {
-  mergeAdvancedFilters
+  consumeAdvancedFilterState,
+  mergeAdvancedFilterTree,
+  mergeAdvancedFilters,
+  mergeAdvancedFiltersFromQuery
 };
 //# sourceMappingURL=advanced-filter-integration.js.map

package/dist/lib/crud/advanced-filter-integration.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/crud/advanced-filter-integration.ts"],
-  "sourcesContent": ["import { deserializeAdvancedFilter, convertAdvancedFilterToWhere } from '../query/advanced-filter'\n\nfunction splitOrClauses(filters: Record<string, unknown>): {\n  directFilters: Record<string, unknown>\n  orClauses: Record<string, unknown>[] | null\n} {\n  const directFilters: Record<string, unknown> = {}\n  let orClauses: Record<string, unknown>[] | null = null\n\n  for (const [key, value] of Object.entries(filters)) {\n    if (key === '$or' && Array.isArray(value)) {\n      orClauses = value.filter((entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry))\n      continue\n    }\n    directFilters[key] = value\n  }\n\n  return { directFilters, orClauses }\n}\n\n/**\n * Parse advanced filter query params and merge with existing Where filters.\n * Call this in buildFilters callback to support advanced filter query params.\n */\nexport function mergeAdvancedFilters(\n  existingFilters: Record<string, unknown>,\n  query: Record<string, unknown>,\n): Record<string, unknown> {\n  const advancedState = deserializeAdvancedFilter(query)\n  if (!advancedState) return existingFilters\n\n  const advancedWhere = convertAdvancedFilterToWhere(advancedState)\n  if (!Object.keys(advancedWhere).length) return existingFilters\n\n  if ('$or' in advancedWhere) {\n    if (!Object.keys(existingFilters).length) return advancedWhere\n\n    const { directFilters: existingDirect, orClauses: existingOrClauses } = splitOrClauses(existingFilters)\n    const advancedClauses = Array.isArray((advancedWhere as { $or?: unknown }).$or)\n      ? ((advancedWhere as { $or: unknown[] }).$or).filter(\n          (entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry),\n        )\n      : []\n\n    if (!advancedClauses.length) return existingFilters\n\n    if (!existingOrClauses?.length) {\n      return {\n        ...existingDirect,\n        $or: advancedClauses,\n      }\n    }\n\n    const combinedClauses: Record<string, unknown>[] = []\n    for (const leftClause of existingOrClauses) {\n      for (const rightClause of advancedClauses) {\n        combinedClauses.push({\n          ...leftClause,\n          ...rightClause,\n        })\n      }\n    }\n\n    return combinedClauses.length\n      ? {\n          ...existingDirect,\n          $or: combinedClauses,\n        }\n      : existingFilters\n  }\n\n  // AND logic: merge directly\n  return { ...existingFilters, ...advancedWhere }\n}\n"],
-  "mappings": "AAAA,SAAS,2BAA2B,oCAAoC;AAExE,SAAS,eAAe,SAGtB;AACA,QAAM,gBAAyC,CAAC;AAChD,MAAI,YAA8C;AAElD,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,OAAO,GAAG;AAClD,QAAI,QAAQ,SAAS,MAAM,QAAQ,KAAK,GAAG;AACzC,kBAAY,MAAM,OAAO,CAAC,UAA4C,QAAQ,KAAK,KAAK,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK,CAAC;AAC1I;AAAA,IACF;AACA,kBAAc,GAAG,IAAI;AAAA,EACvB;AAEA,SAAO,EAAE,eAAe,UAAU;AACpC;AAMO,SAAS,qBACd,iBACA,OACyB;AACzB,QAAM,gBAAgB,0BAA0B,KAAK;AACrD,MAAI,CAAC,cAAe,QAAO;AAE3B,QAAM,gBAAgB,6BAA6B,aAAa;AAChE,MAAI,CAAC,OAAO,KAAK,aAAa,EAAE,OAAQ,QAAO;AAE/C,MAAI,SAAS,eAAe;AAC1B,QAAI,CAAC,OAAO,KAAK,eAAe,EAAE,OAAQ,QAAO;AAEjD,UAAM,EAAE,eAAe,gBAAgB,WAAW,kBAAkB,IAAI,eAAe,eAAe;AACtG,UAAM,kBAAkB,MAAM,QAAS,cAAoC,GAAG,IACxE,cAAqC,IAAK;AAAA,MAC1C,CAAC,UAA4C,QAAQ,KAAK,KAAK,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK;AAAA,IAClH,IACA,CAAC;AAEL,QAAI,CAAC,gBAAgB,OAAQ,QAAO;AAEpC,QAAI,CAAC,mBAAmB,QAAQ;AAC9B,aAAO;AAAA,QACL,GAAG;AAAA,QACH,KAAK;AAAA,MACP;AAAA,IACF;AAEA,UAAM,kBAA6C,CAAC;AACpD,eAAW,cAAc,mBAAmB;AAC1C,iBAAW,eAAe,iBAAiB;AACzC,wBAAgB,KAAK;AAAA,UACnB,GAAG;AAAA,UACH,GAAG;AAAA,QACL,CAAC;AAAA,MACH;AAAA,IACF;AAEA,WAAO,gBAAgB,SACnB;AAAA,MACE,GAAG;AAAA,MACH,KAAK;AAAA,IACP,IACA;AAAA,EACN;AAGA,SAAO,EAAE,GAAG,iBAAiB,GAAG,cAAc;AAChD;",
+  "sourcesContent": ["import {\n  deserializeAdvancedFilter,\n  deserializeTree,\n  flatToTree,\n  convertAdvancedFilterToWhere,\n} from '../query/advanced-filter'\nimport { compileTreeToWhere, type AdvancedFilterTree } from '../query/advanced-filter-tree'\n\nfunction splitOrClauses(filters: Record<string, unknown>): {\n  directFilters: Record<string, unknown>\n  orClauses: Record<string, unknown>[] | null\n} {\n  const directFilters: Record<string, unknown> = {}\n  let orClauses: Record<string, unknown>[] | null = null\n\n  for (const [key, value] of Object.entries(filters)) {\n    if (key === '$or' && Array.isArray(value)) {\n      orClauses = value.filter((entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry))\n      continue\n    }\n    directFilters[key] = value\n  }\n\n  return { directFilters, orClauses }\n}\n\n/**\n * Parse advanced filter query params and merge with existing Where filters.\n * Call this in buildFilters callback to support advanced filter query params.\n */\nexport function mergeAdvancedFilters(\n  existingFilters: Record<string, unknown>,\n  query: Record<string, unknown>,\n): Record<string, unknown> {\n  const advancedState = deserializeAdvancedFilter(query)\n  if (!advancedState) return existingFilters\n\n  const advancedWhere = convertAdvancedFilterToWhere(advancedState)\n  if (!Object.keys(advancedWhere).length) return existingFilters\n\n  if ('$or' in advancedWhere) {\n    if (!Object.keys(existingFilters).length) return advancedWhere\n\n    const { directFilters: existingDirect, orClauses: existingOrClauses } = splitOrClauses(existingFilters)\n    const advancedClauses = Array.isArray((advancedWhere as { $or?: unknown }).$or)\n      ? ((advancedWhere as { $or: unknown[] }).$or).filter(\n          (entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry),\n        )\n      : []\n\n    if (!advancedClauses.length) return existingFilters\n\n    if (!existingOrClauses?.length) {\n      return {\n        ...existingDirect,\n        $or: advancedClauses,\n      }\n    }\n\n    const combinedClauses: Record<string, unknown>[] = []\n    for (const leftClause of existingOrClauses) {\n      for (const rightClause of advancedClauses) {\n        combinedClauses.push({\n          ...leftClause,\n          ...rightClause,\n        })\n      }\n    }\n\n    return combinedClauses.length\n      ? {\n          ...existingDirect,\n          $or: combinedClauses,\n        }\n      : existingFilters\n  }\n\n  // AND logic: merge directly\n  return { ...existingFilters, ...advancedWhere }\n}\n\n/**\n * Combine route-side filters with an advanced filter tree by AND.\n *\n * The compiled tree may itself contain nested `$and`/`$or` \u2014 the query engine's\n * normalize step (`compileToDnf` in join-utils.ts) expands those into Disjunctive\n * Normal Form, so the engine sees a single OR group with disjuncts that AND'd\n * leaves. Common-clause lifting in normalize keeps shared predicates ungrouped\n * (preserving the search-tokens optimization).\n */\nexport function mergeAdvancedFilterTree(\n  routeFilters: Record<string, unknown>,\n  tree: AdvancedFilterTree | null,\n): Record<string, unknown> {\n  if (!tree) return routeFilters\n  const treeWhere = compileTreeToWhere(tree)\n  if (!treeWhere) return routeFilters\n  if (Object.keys(routeFilters).length === 0) return treeWhere\n  // AND-combine via $and so any nested $and/$or in either side reaches normalize unchanged.\n  return { $and: [routeFilters, treeWhere] }\n}\n\n/**\n * Read-old-write-new helper: parse the request `query` for either a v2 tree URL\n * or a legacy v1 flat URL (auto-upgraded via flatToTree under SQL precedence),\n * and AND-combine the result with the route's existing filters.\n */\nexport function mergeAdvancedFiltersFromQuery(\n  routeFilters: Record<string, unknown>,\n  query: Record<string, unknown>,\n): Record<string, unknown> {\n  const v2 = deserializeTree(query)\n  if (v2) return mergeAdvancedFilterTree(routeFilters, v2)\n  const flat = deserializeAdvancedFilter(query)\n  if (!flat) return routeFilters\n  return mergeAdvancedFilterTree(routeFilters, flatToTree(flat))\n}\n\n/**\n * Returns the request's advanced filter as a tree, after stripping the\n * `filter[...]` keys from the query map. Mirrors `mergeAdvancedFiltersFromQuery`\n * but exposes the tree so callers can apply additional shaping (e.g. mapping to\n * `query.ids`, narrowing by feature flags, or surfacing the tree to enrichers)\n * before merging into the route filter.\n *\n * - Detects v2 tree URL params first.\n * - Falls back to legacy v1 flat params, upgraded via `flatToTree` under\n *   standard SQL precedence (AND binds tighter than OR).\n * - Mutates `query` in place: every `filter[...]` key is removed after parsing.\n *\n * Returns `null` when no advanced-filter query params are present.\n */\nexport function consumeAdvancedFilterState(query: Record<string, unknown>): AdvancedFilterTree | null {\n  let tree: AdvancedFilterTree | null = deserializeTree(query)\n  if (!tree) {\n    const flat = deserializeAdvancedFilter(query)\n    if (flat) {\n      tree = flatToTree(flat)\n      if (process.env.NODE_ENV !== 'production') {\n        const sentinel = '__OM_FILTER_V1_WARNED'\n        const g = globalThis as Record<string, unknown>\n        if (!g[sentinel]) {\n          g[sentinel] = true\n          // eslint-disable-next-line no-console\n          console.warn('[advanced-filter] legacy v1 URL detected; auto-upgraded to v2 tree')\n        }\n      }\n    }\n  }\n\n  for (const key of Object.keys(query)) {\n    if (key.startsWith('filter[')) {\n      delete query[key]\n    }\n  }\n\n  return tree\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/lib/query/advanced-filter-tree.js

@@ -0,0 +1,280 @@
+import { isValuelessOperator } from "./advanced-filter.js";
+import { escapeLikePattern } from "../db/escapeLikePattern.js";
+const TREE_LIMITS = {
+  maxGroupLevel: 3,
+  // root = level 1; deepest nested group = level 3
+  maxChildrenPerGroup: 15,
+  // counts both rules and nested groups
+  maxTotalRules: 50
+};
+function createEmptyTree() {
+  return {
+    root: {
+      id: crypto.randomUUID(),
+      type: "group",
+      combinator: "and",
+      children: []
+    }
+  };
+}
+function validateTreeLimits(tree) {
+  let totalRules = 0;
+  function walk(node, level) {
+    if (node.type === "rule") {
+      totalRules += 1;
+      return { ok: true };
+    }
+    if (level > TREE_LIMITS.maxGroupLevel) return { ok: false, reason: "depth" };
+    if (node.children.length > TREE_LIMITS.maxChildrenPerGroup) return { ok: false, reason: "width" };
+    for (const child of node.children) {
+      const r2 = walk(child, level + 1);
+      if (!r2.ok) return r2;
+    }
+    return { ok: true };
+  }
+  const r = walk(tree.root, 1);
+  if (!r.ok) return r;
+  if (totalRules > TREE_LIMITS.maxTotalRules) return { ok: false, reason: "total" };
+  return { ok: true };
+}
+function normalizeSingleValue(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeListValue(value) {
+  const list = Array.isArray(value) ? value : [value];
+  return list.map(normalizeSingleValue).filter((v) => v !== null);
+}
+function compileRule(rule) {
+  if (!rule.field || !rule.operator) return null;
+  const filter = {};
+  switch (rule.operator) {
+    case "is":
+    case "equals": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $eq: v };
+      break;
+    }
+    case "is_not":
+    case "not_equals": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $ne: v };
+      break;
+    }
+    case "contains": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $ilike: `%${escapeLikePattern(String(v))}%` };
+      break;
+    }
+    case "does_not_contain": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $not: { $ilike: `%${escapeLikePattern(String(v))}%` } };
+      break;
+    }
+    case "starts_with": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $ilike: `${escapeLikePattern(String(v))}%` };
+      break;
+    }
+    case "ends_with": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $ilike: `%${escapeLikePattern(String(v))}` };
+      break;
+    }
+    case "is_empty":
+      filter[rule.field] = { $exists: false };
+      break;
+    case "is_not_empty":
+      filter[rule.field] = { $exists: true };
+      break;
+    case "greater_than": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $gt: v };
+      break;
+    }
+    case "less_than": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $lt: v };
+      break;
+    }
+    case "greater_or_equal": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $gte: v };
+      break;
+    }
+    case "less_or_equal": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $lte: v };
+      break;
+    }
+    case "between": {
+      if (Array.isArray(rule.value) && rule.value.length === 2) {
+        const start = normalizeSingleValue(rule.value[0]);
+        const end = normalizeSingleValue(rule.value[1]);
+        if (start === null && end === null) return null;
+        if (start !== null && end !== null) filter[rule.field] = { $gte: start, $lte: end };
+        else if (start !== null) filter[rule.field] = { $gte: start };
+        else filter[rule.field] = { $lte: end };
+      } else {
+        return null;
+      }
+      break;
+    }
+    case "is_before": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $lt: v };
+      break;
+    }
+    case "is_after": {
+      const v = normalizeSingleValue(rule.value);
+      if (v === null) return null;
+      filter[rule.field] = { $gt: v };
+      break;
+    }
+    case "is_any_of":
+    case "has_any_of": {
+      const list = normalizeListValue(rule.value);
+      if (list.length === 0) return null;
+      filter[rule.field] = { $in: list };
+      break;
+    }
+    case "is_none_of":
+    case "has_none_of": {
+      const list = normalizeListValue(rule.value);
+      if (list.length === 0) return null;
+      filter[rule.field] = { $nin: list };
+      break;
+    }
+    case "has_all_of": {
+      const list = normalizeListValue(rule.value);
+      if (list.length === 0) return null;
+      filter[rule.field] = { $contains: list };
+      break;
+    }
+    case "is_true":
+      filter[rule.field] = { $eq: true };
+      break;
+    case "is_false":
+      filter[rule.field] = { $eq: false };
+      break;
+  }
+  return Object.keys(filter).length > 0 ? filter : null;
+}
+function compileTreeToWhere(tree) {
+  return compileGroup(tree.root);
+}
+function compileGroup(node) {
+  const compiled = node.children.map((child) => child.type === "rule" ? compileRule(child) : compileGroup(child)).filter((c) => c !== null);
+  if (compiled.length === 0) return null;
+  if (compiled.length === 1) return compiled[0];
+  return node.combinator === "or" ? { $or: compiled } : { $and: compiled };
+}
+function makeRuleTree(rule) {
+  const ruleNode = {
+    id: crypto.randomUUID(),
+    type: "rule",
+    field: rule.field,
+    operator: rule.operator,
+    value: rule.value
+  };
+  return {
+    root: {
+      id: crypto.randomUUID(),
+      type: "group",
+      combinator: "and",
+      children: [ruleNode]
+    }
+  };
+}
+function stripRuntimeMetadataDeep(node) {
+  if (node.type === "rule") {
+    const { addedAt: _ignored2, ...rest2 } = node;
+    return rest2;
+  }
+  const { addedAt: _ignored, children, ...rest } = node;
+  const cleanChildren = children.map((c) => stripRuntimeMetadataDeep(c));
+  return { ...rest, children: cleanChildren };
+}
+function serializeTreeForPersist(tree) {
+  return { v: 2, root: stripRuntimeMetadataDeep(tree.root) };
+}
+function isPersistedFilterTree(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  if (record.v !== 2) return false;
+  const root = record.root;
+  if (!root || typeof root !== "object") return false;
+  const r = root;
+  return r.type === "group" && (r.combinator === "and" || r.combinator === "or") && Array.isArray(r.children);
+}
+function deserializeTreeFromPersist(value) {
+  if (!isPersistedFilterTree(value)) return null;
+  return { root: value.root };
+}
+function treeToFlat(tree) {
+  const conditions = [];
+  function walk(group, parentJoin) {
+    for (const child of group.children) {
+      if (child.type === "rule") {
+        conditions.push({
+          id: child.id,
+          field: child.field,
+          operator: child.operator,
+          value: child.value,
+          // First rule overall gets 'and' (it has no left neighbor); the rest
+          // inherit the parent group's combinator.
+          join: conditions.length === 0 ? "and" : parentJoin
+        });
+      } else {
+        walk(child, child.combinator);
+      }
+    }
+  }
+  walk(tree.root, tree.root.combinator);
+  return { logic: tree.root.combinator, conditions };
+}
+function makeMultiRuleTree(rules, combinator = "and") {
+  return {
+    root: {
+      id: crypto.randomUUID(),
+      type: "group",
+      combinator,
+      children: rules.map((rule) => {
+        const node = {
+          id: crypto.randomUUID(),
+          type: "rule",
+          field: rule.field,
+          operator: rule.operator,
+          value: rule.value
+        };
+        return node;
+      })
+    }
+  };
+}
+export {
+  TREE_LIMITS,
+  compileTreeToWhere,
+  createEmptyTree,
+  deserializeTreeFromPersist,
+  isPersistedFilterTree,
+  isValuelessOperator,
+  makeMultiRuleTree,
+  makeRuleTree,
+  serializeTreeForPersist,
+  treeToFlat,
+  validateTreeLimits
+};
+//# sourceMappingURL=advanced-filter-tree.js.map

package/dist/lib/query/advanced-filter-tree.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/query/advanced-filter-tree.ts"],
+  "sourcesContent": ["// packages/shared/src/lib/query/advanced-filter-tree.ts\nimport type { FilterOperator } from './advanced-filter'\nimport { isValuelessOperator } from './advanced-filter'\nimport { escapeLikePattern } from '../db/escapeLikePattern'\n\nexport type FilterCombinator = 'and' | 'or'\n\nexport type FilterRule = {\n  id: string\n  type: 'rule'\n  field: string\n  operator: FilterOperator\n  value: unknown\n  // Runtime-only metadata used by the editor reducer (e.g. removeLast) to find\n  // the most recently inserted node. MUST NOT be serialized into URL or persisted state.\n  addedAt?: number\n}\n\nexport type FilterGroup = {\n  id: string\n  type: 'group'\n  combinator: FilterCombinator\n  children: Array<FilterRule | FilterGroup>\n  // Runtime-only metadata used by the editor reducer (e.g. removeLast) to find\n  // the most recently inserted node. MUST NOT be serialized into URL or persisted state.\n  addedAt?: number\n}\n\nexport type AdvancedFilterTree = {\n  root: FilterGroup\n}\n\nexport const TREE_LIMITS = {\n  maxGroupLevel: 3,        // root = level 1; deepest nested group = level 3\n  maxChildrenPerGroup: 15, // counts both rules and nested groups\n  maxTotalRules: 50,\n} as const\n\nexport function createEmptyTree(): AdvancedFilterTree {\n  return {\n    root: {\n      id: crypto.randomUUID(),\n      type: 'group',\n      combinator: 'and',\n      children: [],\n    },\n  }\n}\n\nexport type ValidationResult =\n  | { ok: true }\n  | { ok: false; reason: 'depth' | 'width' | 'total' }\n\nexport function validateTreeLimits(tree: AdvancedFilterTree): ValidationResult {\n  let totalRules = 0\n  function walk(node: FilterRule | FilterGroup, level: number): ValidationResult {\n    if (node.type === 'rule') {\n      totalRules += 1\n      return { ok: true }\n    }\n    if (level > TREE_LIMITS.maxGroupLevel) return { ok: false, reason: 'depth' }\n    if (node.children.length > TREE_LIMITS.maxChildrenPerGroup) return { ok: false, reason: 'width' }\n    for (const child of node.children) {\n      const r = walk(child, level + 1)\n      if (!r.ok) return r\n    }\n    return { ok: true }\n  }\n  const r = walk(tree.root, 1)\n  if (!r.ok) return r\n  if (totalRules > TREE_LIMITS.maxTotalRules) return { ok: false, reason: 'total' }\n  return { ok: true }\n}\n\nfunction normalizeSingleValue(value: unknown): unknown {\n  if (typeof value !== 'string') return value\n  const trimmed = value.trim()\n  return trimmed.length > 0 ? trimmed : null\n}\n\nfunction normalizeListValue(value: unknown): unknown[] {\n  const list = Array.isArray(value) ? value : [value]\n  return list.map(normalizeSingleValue).filter((v) => v !== null)\n}\n\nfunction compileRule(rule: FilterRule): Record<string, unknown> | null {\n  if (!rule.field || !rule.operator) return null\n  const filter: Record<string, unknown> = {}\n  switch (rule.operator) {\n    case 'is':\n    case 'equals': {\n      const v = normalizeSingleValue(rule.value)\n      if (v === null) return null\n      filter[rule.field] = { $eq: v }; break\n    }\n    case 'is_not':\n    case 'not_equals': {\n      const v = normalizeSingleValue(rule.value)\n      if (v === null) return null\n      filter[rule.field] = { $ne: v }; break\n    }\n    case 'contains': {\n      const v = normalizeSingleValue(rule.value)\n      if (v === null) return null\n      filter[rule.field] = { $ilike: `%${escapeLikePattern(String(v))}%` }; break\n    }\n    case 'does_not_contain': {\n      const v = normalizeSingleValue(rule.value)\n      if (v === null) return null\n      filter[rule.field] = { $not: { $ilike: `%${escapeLikePattern(String(v))}%` } }; break\n    }\n    case 'starts_with': {\n      const v = normalizeSingleValue(rule.value)\n      if (v === null) return null\n      filter[rule.field] = { $ilike: `${escapeLikePattern(String(v))}%` }; break\n    }\n    case 'ends_with': {\n      const v = normalizeSingleValue(rule.value)\n      if (v === null) return null\n      filter[rule.field] = { $ilike: `%${escapeLikePattern(String(v))}` }; break\n    }\n    case 'is_empty': filter[rule.field] = { $exists: false }; break\n    case 'is_not_empty': filter[rule.field] = { $exists: true }; break\n    case 'greater_than': { const v = normalizeSingleValue(rule.value); if (v === null) return null; filter[rule.field] = { $gt: v }; break }\n    case 'less_than': { const v = normalizeSingleValue(rule.value); if (v === null) return null; filter[rule.field] = { $lt: v }; break }\n    case 'greater_or_equal': { const v = normalizeSingleValue(rule.value); if (v === null) return null; filter[rule.field] = { $gte: v }; break }\n    case 'less_or_equal': { const v = normalizeSingleValue(rule.value); if (v === null) return null; filter[rule.field] = { $lte: v }; break }\n    case 'between': {\n      if (Array.isArray(rule.value) && rule.value.length === 2) {\n        const start = normalizeSingleValue(rule.value[0])\n        const end = normalizeSingleValue(rule.value[1])\n        if (start === null && end === null) return null\n        if (start !== null && end !== null) filter[rule.field] = { $gte: start, $lte: end }\n        else if (start !== null) filter[rule.field] = { $gte: start }\n        else filter[rule.field] = { $lte: end }\n      } else {\n        return null\n      }\n      break\n    }\n    case 'is_before': { const v = normalizeSingleValue(rule.value); if (v === null) return null; filter[rule.field] = { $lt: v }; break }\n    case 'is_after': { const v = normalizeSingleValue(rule.value); if (v === null) return null; filter[rule.field] = { $gt: v }; break }\n    case 'is_any_of':\n    case 'has_any_of': {\n      const list = normalizeListValue(rule.value)\n      if (list.length === 0) return null\n      filter[rule.field] = { $in: list }; break\n    }\n    case 'is_none_of':\n    case 'has_none_of': {\n      const list = normalizeListValue(rule.value)\n      if (list.length === 0) return null\n      filter[rule.field] = { $nin: list }; break\n    }\n    case 'has_all_of': {\n      const list = normalizeListValue(rule.value)\n      if (list.length === 0) return null\n      filter[rule.field] = { $contains: list }; break\n    }\n    case 'is_true': filter[rule.field] = { $eq: true }; break\n    case 'is_false': filter[rule.field] = { $eq: false }; break\n  }\n  return Object.keys(filter).length > 0 ? filter : null\n}\n\nexport function compileTreeToWhere(tree: AdvancedFilterTree): Record<string, unknown> | null {\n  return compileGroup(tree.root)\n}\n\nfunction compileGroup(node: FilterGroup): Record<string, unknown> | null {\n  const compiled = node.children\n    .map((child) => (child.type === 'rule' ? compileRule(child) : compileGroup(child)))\n    .filter((c): c is Record<string, unknown> => c !== null)\n  if (compiled.length === 0) return null\n  if (compiled.length === 1) return compiled[0]\n  return node.combinator === 'or' ? { $or: compiled } : { $and: compiled }\n}\n\n// Re-export isValuelessOperator so consumers of this module can access it\nexport { isValuelessOperator }\n\n/**\n * Build a single-rule tree wrapped in an AND root group.\n * Useful for quick-filter presets that apply one rule.\n */\nexport function makeRuleTree(rule: { field: string; operator: FilterOperator; value: unknown }): AdvancedFilterTree {\n  const ruleNode: FilterRule = {\n    id: crypto.randomUUID(),\n    type: 'rule',\n    field: rule.field,\n    operator: rule.operator,\n    value: rule.value,\n  }\n  return {\n    root: {\n      id: crypto.randomUUID(),\n      type: 'group',\n      combinator: 'and',\n      children: [ruleNode],\n    },\n  }\n}\n\n/**\n * Persisted shape of an `AdvancedFilterTree` inside `PerspectiveSettings.filters`.\n * The `v: 2` marker disambiguates the tree from legacy flat `FilterValues` and\n * from the plain `{root: ...}` shape. Runtime-only `addedAt` is stripped before\n * persisting so saved perspectives are deterministic across reloads.\n */\nexport type PersistedFilterTree = {\n  v: 2\n  root: FilterGroup\n}\n\nfunction stripRuntimeMetadataDeep<T extends FilterRule | FilterGroup>(node: T): T {\n  if (node.type === 'rule') {\n    const { addedAt: _ignored, ...rest } = node as FilterRule & { addedAt?: number }\n    return rest as T\n  }\n  const { addedAt: _ignored, children, ...rest } = node as FilterGroup & { addedAt?: number }\n  const cleanChildren = children.map((c) => stripRuntimeMetadataDeep(c))\n  return { ...rest, children: cleanChildren } as T\n}\n\n/** Serialize a tree for persistence (perspective settings, exports, etc.). */\nexport function serializeTreeForPersist(tree: AdvancedFilterTree): PersistedFilterTree {\n  return { v: 2, root: stripRuntimeMetadataDeep(tree.root) }\n}\n\n/** Type guard: does `value` look like a persisted filter tree? */\nexport function isPersistedFilterTree(value: unknown): value is PersistedFilterTree {\n  if (!value || typeof value !== 'object') return false\n  const record = value as Record<string, unknown>\n  if (record.v !== 2) return false\n  const root = record.root\n  if (!root || typeof root !== 'object') return false\n  const r = root as Record<string, unknown>\n  return r.type === 'group' && (r.combinator === 'and' || r.combinator === 'or') && Array.isArray(r.children)\n}\n\n/**\n * Restore a tree from its persisted shape. Returns `null` when the input is\n * not a recognizable persisted tree \u2014 callers should fall back to legacy\n * filter handling in that case.\n */\nexport function deserializeTreeFromPersist(value: unknown): AdvancedFilterTree | null {\n  if (!isPersistedFilterTree(value)) return null\n  return { root: value.root }\n}\n\n/**\n * Best-effort back-conversion of a tree to the legacy flat `AdvancedFilterState`\n * shape (`{logic, conditions[]}`). The flat shape only supports a single level\n * of AND/OR joining between sibling conditions; nested groups are flattened by\n * walking all leaf rules into the top level. Use this only for the legacy\n * `DataTable.advancedFilter` BC bridge \u2014 new code should keep the tree shape.\n *\n * The function picks `logic` from the root group's combinator and uses each\n * rule's parent-group combinator as its `join`. The first rule's `join` is\n * always `'and'` (it has no left neighbor).\n */\nexport function treeToFlat(tree: AdvancedFilterTree): {\n  logic: 'and' | 'or'\n  conditions: Array<{\n    id: string\n    field: string\n    operator: import('./advanced-filter').FilterOperator\n    value: unknown\n    join: 'and' | 'or'\n  }>\n} {\n  const conditions: Array<{\n    id: string\n    field: string\n    operator: import('./advanced-filter').FilterOperator\n    value: unknown\n    join: 'and' | 'or'\n  }> = []\n\n  function walk(group: FilterGroup, parentJoin: 'and' | 'or') {\n    for (const child of group.children) {\n      if (child.type === 'rule') {\n        conditions.push({\n          id: child.id,\n          field: child.field,\n          operator: child.operator,\n          value: child.value,\n          // First rule overall gets 'and' (it has no left neighbor); the rest\n          // inherit the parent group's combinator.\n          join: conditions.length === 0 ? 'and' : parentJoin,\n        })\n      } else {\n        walk(child, child.combinator)\n      }\n    }\n  }\n  walk(tree.root, tree.root.combinator)\n\n  return { logic: tree.root.combinator, conditions }\n}\n\n/**\n * Build a multi-rule tree wrapped in a root group with the given combinator.\n * Useful for quick-filter presets that combine multiple rules (e.g.\n * `status is win AND close_date is_after start_of_quarter`).\n */\nexport function makeMultiRuleTree(\n  rules: Array<{ field: string; operator: FilterOperator; value: unknown }>,\n  combinator: FilterCombinator = 'and',\n): AdvancedFilterTree {\n  return {\n    root: {\n      id: crypto.randomUUID(),\n      type: 'group',\n      combinator,\n      children: rules.map((rule) => {\n        const node: FilterRule = {\n          id: crypto.randomUUID(),\n          type: 'rule',\n          field: rule.field,\n          operator: rule.operator,\n          value: rule.value,\n        }\n        return node\n      }),\n    },\n  }\n}\n"],
+  "mappings": "AAEA,SAAS,2BAA2B;AACpC,SAAS,yBAAyB;AA6B3B,MAAM,cAAc;AAAA,EACzB,eAAe;AAAA;AAAA,EACf,qBAAqB;AAAA;AAAA,EACrB,eAAe;AACjB;AAEO,SAAS,kBAAsC;AACpD,SAAO;AAAA,IACL,MAAM;AAAA,MACJ,IAAI,OAAO,WAAW;AAAA,MACtB,MAAM;AAAA,MACN,YAAY;AAAA,MACZ,UAAU,CAAC;AAAA,IACb;AAAA,EACF;AACF;AAMO,SAAS,mBAAmB,MAA4C;AAC7E,MAAI,aAAa;AACjB,WAAS,KAAK,MAAgC,OAAiC;AAC7E,QAAI,KAAK,SAAS,QAAQ;AACxB,oBAAc;AACd,aAAO,EAAE,IAAI,KAAK;AAAA,IACpB;AACA,QAAI,QAAQ,YAAY,cAAe,QAAO,EAAE,IAAI,OAAO,QAAQ,QAAQ;AAC3E,QAAI,KAAK,SAAS,SAAS,YAAY,oBAAqB,QAAO,EAAE,IAAI,OAAO,QAAQ,QAAQ;AAChG,eAAW,SAAS,KAAK,UAAU;AACjC,YAAMA,KAAI,KAAK,OAAO,QAAQ,CAAC;AAC/B,UAAI,CAACA,GAAE,GAAI,QAAOA;AAAA,IACpB;AACA,WAAO,EAAE,IAAI,KAAK;AAAA,EACpB;AACA,QAAM,IAAI,KAAK,KAAK,MAAM,CAAC;AAC3B,MAAI,CAAC,EAAE,GAAI,QAAO;AAClB,MAAI,aAAa,YAAY,cAAe,QAAO,EAAE,IAAI,OAAO,QAAQ,QAAQ;AAChF,SAAO,EAAE,IAAI,KAAK;AACpB;AAEA,SAAS,qBAAqB,OAAyB;AACrD,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,QAAM,UAAU,MAAM,KAAK;AAC3B,SAAO,QAAQ,SAAS,IAAI,UAAU;AACxC;AAEA,SAAS,mBAAmB,OAA2B;AACrD,QAAM,OAAO,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;AAClD,SAAO,KAAK,IAAI,oBAAoB,EAAE,OAAO,CAAC,MAAM,MAAM,IAAI;AAChE;AAEA,SAAS,YAAY,MAAkD;AACrE,MAAI,CAAC,KAAK,SAAS,CAAC,KAAK,SAAU,QAAO;AAC1C,QAAM,SAAkC,CAAC;AACzC,UAAQ,KAAK,UAAU;AAAA,IACrB,KAAK;AAAA,IACL,KAAK,UAAU;AACb,YAAM,IAAI,qBAAqB,KAAK,KAAK;AACzC,UAAI,MAAM,KAAM,QAAO;AACvB,aAAO,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE;AAAG;AAAA,IACnC;AAAA,IACA,KAAK;AAAA,IACL,KAAK,cAAc;AACjB,YAAM,IAAI,qBAAqB,KAAK,KAAK;AACzC,UAAI,MAAM,KAAM,QAAO;AACvB,aAAO,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE;AAAG;AAAA,IACnC;AAAA,IACA,KAAK,YAAY;AACf,YAAM,IAAI,qBAAqB,KAAK,KAAK;AACzC,UAAI,MAAM,KAAM,QAAO;AACvB,aAAO,KAAK,KAAK,IAAI,EAAE,QAAQ,IAAI,kBAAkB,OAAO,CAAC,CAAC,CAAC,IAAI;AAAG;AAAA,IACxE;AAAA,IACA,KAAK,oBAAoB;AACvB,YAAM,IAAI,qBAAqB,KAAK,KAAK;AACzC,UAAI,MAAM,KAAM,QAAO;AACvB,aAAO,KAAK,KAAK,IAAI,EAAE,MAAM,EAAE,QAAQ,IAAI,kBAAkB,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE;AAAG;AAAA,IAClF;AAAA,IACA,KAAK,eAAe;AAClB,YAAM,IAAI,qBAAqB,KAAK,KAAK;AACzC,UAAI,MAAM,KAAM,QAAO;AACvB,aAAO,KAAK,KAAK,IAAI,EAAE,QAAQ,GAAG,kBAAkB,OAAO,CAAC,CAAC,CAAC,IAAI;AAAG;AAAA,IACvE;AAAA,IACA,KAAK,aAAa;AAChB,YAAM,IAAI,qBAAqB,KAAK,KAAK;AACzC,UAAI,MAAM,KAAM,QAAO;AACvB,aAAO,KAAK,KAAK,IAAI,EAAE,QAAQ,IAAI,kBAAkB,OAAO,CAAC,CAAC,CAAC,GAAG;AAAG;AAAA,IACvE;AAAA,IACA,KAAK;AAAY,aAAO,KAAK,KAAK,IAAI,EAAE,SAAS,MAAM;AAAG;AAAA,IAC1D,KAAK;AAAgB,aAAO,KAAK,KAAK,IAAI,EAAE,SAAS,KAAK;AAAG;AAAA,IAC7D,KAAK,gBAAgB;AAAE,YAAM,IAAI,qBAAqB,KAAK,KAAK;AAAG,UAAI,MAAM,KAAM,QAAO;AAAM,aAAO,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE;AAAG;AAAA,IAAM;AAAA,IACvI,KAAK,aAAa;AAAE,YAAM,IAAI,qBAAqB,KAAK,KAAK;AAAG,UAAI,MAAM,KAAM,QAAO;AAAM,aAAO,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE;AAAG;AAAA,IAAM;AAAA,IACpI,KAAK,oBAAoB;AAAE,YAAM,IAAI,qBAAqB,KAAK,KAAK;AAAG,UAAI,MAAM,KAAM,QAAO;AAAM,aAAO,KAAK,KAAK,IAAI,EAAE,MAAM,EAAE;AAAG;AAAA,IAAM;AAAA,IAC5I,KAAK,iBAAiB;AAAE,YAAM,IAAI,qBAAqB,KAAK,KAAK;AAAG,UAAI,MAAM,KAAM,QAAO;AAAM,aAAO,KAAK,KAAK,IAAI,EAAE,MAAM,EAAE;AAAG;AAAA,IAAM;AAAA,IACzI,KAAK,WAAW;AACd,UAAI,MAAM,QAAQ,KAAK,KAAK,KAAK,KAAK,MAAM,WAAW,GAAG;AACxD,cAAM,QAAQ,qBAAqB,KAAK,MAAM,CAAC,CAAC;AAChD,cAAM,MAAM,qBAAqB,KAAK,MAAM,CAAC,CAAC;AAC9C,YAAI,UAAU,QAAQ,QAAQ,KAAM,QAAO;AAC3C,YAAI,UAAU,QAAQ,QAAQ,KAAM,QAAO,KAAK,KAAK,IAAI,EAAE,MAAM,OAAO,MAAM,IAAI;AAAA,iBACzE,UAAU,KAAM,QAAO,KAAK,KAAK,IAAI,EAAE,MAAM,MAAM;AAAA,YACvD,QAAO,KAAK,KAAK,IAAI,EAAE,MAAM,IAAI;AAAA,MACxC,OAAO;AACL,eAAO;AAAA,MACT;AACA;AAAA,IACF;AAAA,IACA,KAAK,aAAa;AAAE,YAAM,IAAI,qBAAqB,KAAK,KAAK;AAAG,UAAI,MAAM,KAAM,QAAO;AAAM,aAAO,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE;AAAG;AAAA,IAAM;AAAA,IACpI,KAAK,YAAY;AAAE,YAAM,IAAI,qBAAqB,KAAK,KAAK;AAAG,UAAI,MAAM,KAAM,QAAO;AAAM,aAAO,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE;AAAG;AAAA,IAAM;AAAA,IACnI,KAAK;AAAA,IACL,KAAK,cAAc;AACjB,YAAM,OAAO,mBAAmB,KAAK,KAAK;AAC1C,UAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,aAAO,KAAK,KAAK,IAAI,EAAE,KAAK,KAAK;AAAG;AAAA,IACtC;AAAA,IACA,KAAK;AAAA,IACL,KAAK,eAAe;AAClB,YAAM,OAAO,mBAAmB,KAAK,KAAK;AAC1C,UAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,aAAO,KAAK,KAAK,IAAI,EAAE,MAAM,KAAK;AAAG;AAAA,IACvC;AAAA,IACA,KAAK,cAAc;AACjB,YAAM,OAAO,mBAAmB,KAAK,KAAK;AAC1C,UAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,aAAO,KAAK,KAAK,IAAI,EAAE,WAAW,KAAK;AAAG;AAAA,IAC5C;AAAA,IACA,KAAK;AAAW,aAAO,KAAK,KAAK,IAAI,EAAE,KAAK,KAAK;AAAG;AAAA,IACpD,KAAK;AAAY,aAAO,KAAK,KAAK,IAAI,EAAE,KAAK,MAAM;AAAG;AAAA,EACxD;AACA,SAAO,OAAO,KAAK,MAAM,EAAE,SAAS,IAAI,SAAS;AACnD;AAEO,SAAS,mBAAmB,MAA0D;AAC3F,SAAO,aAAa,KAAK,IAAI;AAC/B;AAEA,SAAS,aAAa,MAAmD;AACvE,QAAM,WAAW,KAAK,SACnB,IAAI,CAAC,UAAW,MAAM,SAAS,SAAS,YAAY,KAAK,IAAI,aAAa,KAAK,CAAE,EACjF,OAAO,CAAC,MAAoC,MAAM,IAAI;AACzD,MAAI,SAAS,WAAW,EAAG,QAAO;AAClC,MAAI,SAAS,WAAW,EAAG,QAAO,SAAS,CAAC;AAC5C,SAAO,KAAK,eAAe,OAAO,EAAE,KAAK,SAAS,IAAI,EAAE,MAAM,SAAS;AACzE;AASO,SAAS,aAAa,MAAuF;AAClH,QAAM,WAAuB;AAAA,IAC3B,IAAI,OAAO,WAAW;AAAA,IACtB,MAAM;AAAA,IACN,OAAO,KAAK;AAAA,IACZ,UAAU,KAAK;AAAA,IACf,OAAO,KAAK;AAAA,EACd;AACA,SAAO;AAAA,IACL,MAAM;AAAA,MACJ,IAAI,OAAO,WAAW;AAAA,MACtB,MAAM;AAAA,MACN,YAAY;AAAA,MACZ,UAAU,CAAC,QAAQ;AAAA,IACrB;AAAA,EACF;AACF;AAaA,SAAS,yBAA6D,MAAY;AAChF,MAAI,KAAK,SAAS,QAAQ;AACxB,UAAM,EAAE,SAASC,WAAU,GAAGC,MAAK,IAAI;AACvC,WAAOA;AAAA,EACT;AACA,QAAM,EAAE,SAAS,UAAU,UAAU,GAAG,KAAK,IAAI;AACjD,QAAM,gBAAgB,SAAS,IAAI,CAAC,MAAM,yBAAyB,CAAC,CAAC;AACrE,SAAO,EAAE,GAAG,MAAM,UAAU,cAAc;AAC5C;AAGO,SAAS,wBAAwB,MAA+C;AACrF,SAAO,EAAE,GAAG,GAAG,MAAM,yBAAyB,KAAK,IAAI,EAAE;AAC3D;AAGO,SAAS,sBAAsB,OAA8C;AAClF,MAAI,CAAC,SAAS,OAAO,UAAU,SAAU,QAAO;AAChD,QAAM,SAAS;AACf,MAAI,OAAO,MAAM,EAAG,QAAO;AAC3B,QAAM,OAAO,OAAO;AACpB,MAAI,CAAC,QAAQ,OAAO,SAAS,SAAU,QAAO;AAC9C,QAAM,IAAI;AACV,SAAO,EAAE,SAAS,YAAY,EAAE,eAAe,SAAS,EAAE,eAAe,SAAS,MAAM,QAAQ,EAAE,QAAQ;AAC5G;AAOO,SAAS,2BAA2B,OAA2C;AACpF,MAAI,CAAC,sBAAsB,KAAK,EAAG,QAAO;AAC1C,SAAO,EAAE,MAAM,MAAM,KAAK;AAC5B;AAaO,SAAS,WAAW,MASzB;AACA,QAAM,aAMD,CAAC;AAEN,WAAS,KAAK,OAAoB,YAA0B;AAC1D,eAAW,SAAS,MAAM,UAAU;AAClC,UAAI,MAAM,SAAS,QAAQ;AACzB,mBAAW,KAAK;AAAA,UACd,IAAI,MAAM;AAAA,UACV,OAAO,MAAM;AAAA,UACb,UAAU,MAAM;AAAA,UAChB,OAAO,MAAM;AAAA;AAAA;AAAA,UAGb,MAAM,WAAW,WAAW,IAAI,QAAQ;AAAA,QAC1C,CAAC;AAAA,MACH,OAAO;AACL,aAAK,OAAO,MAAM,UAAU;AAAA,MAC9B;AAAA,IACF;AAAA,EACF;AACA,OAAK,KAAK,MAAM,KAAK,KAAK,UAAU;AAEpC,SAAO,EAAE,OAAO,KAAK,KAAK,YAAY,WAAW;AACnD;AAOO,SAAS,kBACd,OACA,aAA+B,OACX;AACpB,SAAO;AAAA,IACL,MAAM;AAAA,MACJ,IAAI,OAAO,WAAW;AAAA,MACtB,MAAM;AAAA,MACN;AAAA,MACA,UAAU,MAAM,IAAI,CAAC,SAAS;AAC5B,cAAM,OAAmB;AAAA,UACvB,IAAI,OAAO,WAAW;AAAA,UACtB,MAAM;AAAA,UACN,OAAO,KAAK;AAAA,UACZ,UAAU,KAAK;AAAA,UACf,OAAO,KAAK;AAAA,QACd;AACA,eAAO;AAAA,MACT,CAAC;AAAA,IACH;AAAA,EACF;AACF;",
+  "names": ["r", "_ignored", "rest"]
+}

package/dist/lib/query/advanced-filter.js

@@ -259,15 +259,182 @@ function convertAdvancedFilterToWhere(state) {
   }
   return clauses.length > 1 ? { $or: clauses } : clauses[0];
 }
+function serializeTree(tree) {
+  if (!treeHasRules(tree.root)) return {};
+  const out = { "filter[v]": "2" };
+  serializeTreeGroup(tree.root, "filter[root]", out);
+  return out;
+}
+function treeHasRules(group) {
+  return group.children.some((child) => child.type === "rule" || treeHasRules(child));
+}
+function serializeTreeGroup(group, prefix, out) {
+  out[`${prefix}[combinator]`] = group.combinator;
+  group.children.forEach((child, idx) => {
+    const childPrefix = `${prefix}[children][${idx}]`;
+    if (child.type === "rule") serializeTreeRule(child, childPrefix, out);
+    else {
+      out[`${childPrefix}[type]`] = "group";
+      serializeTreeGroup(child, childPrefix, out);
+    }
+  });
+}
+function serializeTreeRule(rule, prefix, out) {
+  out[`${prefix}[type]`] = "rule";
+  out[`${prefix}[field]`] = rule.field;
+  out[`${prefix}[op]`] = rule.operator;
+  if (!isValuelessOperator(rule.operator) && rule.value != null) {
+    out[`${prefix}[value]`] = typeof rule.value === "object" ? JSON.stringify(rule.value) : String(rule.value);
+  }
+}
+function deserializeTree(query) {
+  if (query["filter[v]"] !== "2") return null;
+  const root = readTreeGroup("filter[root]", query);
+  if (!root) return null;
+  return { root };
+}
+function readTreeGroup(prefix, query) {
+  const combRaw = query[`${prefix}[combinator]`];
+  if (combRaw !== "and" && combRaw !== "or") return null;
+  const children = [];
+  for (let i = 0; i < 64; i++) {
+    const childPrefix = `${prefix}[children][${i}]`;
+    const type = query[`${childPrefix}[type]`];
+    if (type === "rule") {
+      const field = query[`${childPrefix}[field]`];
+      const op = query[`${childPrefix}[op]`];
+      if (typeof field !== "string" || typeof op !== "string" || !isValidOperator(op)) continue;
+      const rawVal = query[`${childPrefix}[value]`];
+      children.push({
+        id: crypto.randomUUID(),
+        type: "rule",
+        field,
+        operator: op,
+        value: parseSerializedFilterValue(rawVal)
+      });
+    } else if (type === "group") {
+      const sub = readTreeGroup(childPrefix, query);
+      if (sub) children.push(sub);
+    } else {
+      break;
+    }
+  }
+  return {
+    id: crypto.randomUUID(),
+    type: "group",
+    combinator: combRaw,
+    children
+  };
+}
+function isAdvancedFilterState(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return Array.isArray(record.conditions) && (record.logic === "and" || record.logic === "or");
+}
+function flatToTree(flat) {
+  if (flat.conditions.length === 0) {
+    return { root: { id: crypto.randomUUID(), type: "group", combinator: "and", children: [] } };
+  }
+  const andRuns = [[flat.conditions[0]]];
+  for (let i = 1; i < flat.conditions.length; i++) {
+    const c = flat.conditions[i];
+    if (c.join === "or") andRuns.push([c]);
+    else andRuns[andRuns.length - 1].push(c);
+  }
+  const ruleFromCondition = (c) => ({
+    id: crypto.randomUUID(),
+    type: "rule",
+    field: c.field,
+    operator: c.operator,
+    value: c.value
+  });
+  const orChildren = andRuns.map((run) => {
+    if (run.length === 1) return ruleFromCondition(run[0]);
+    return {
+      id: crypto.randomUUID(),
+      type: "group",
+      combinator: "and",
+      children: run.map(ruleFromCondition)
+    };
+  });
+  if (orChildren.length === 1) {
+    const only = orChildren[0];
+    if (only.type === "group") return { root: only };
+    return { root: { id: crypto.randomUUID(), type: "group", combinator: "and", children: [only] } };
+  }
+  return {
+    root: { id: crypto.randomUUID(), type: "group", combinator: "or", children: orChildren }
+  };
+}
+function mapDictionaryColorToTone(color) {
+  if (!color || typeof color !== "string") return void 0;
+  const trimmed = color.trim().toLowerCase();
+  if (!trimmed) return void 0;
+  const named = {
+    red: "error",
+    crimson: "error",
+    pink: "pink",
+    rose: "pink",
+    fuchsia: "pink",
+    magenta: "pink",
+    green: "success",
+    emerald: "success",
+    lime: "success",
+    teal: "success",
+    amber: "warning",
+    yellow: "warning",
+    orange: "warning",
+    blue: "info",
+    cyan: "info",
+    sky: "info",
+    indigo: "info",
+    gray: "neutral",
+    grey: "neutral",
+    slate: "neutral",
+    zinc: "neutral",
+    stone: "neutral",
+    violet: "brand",
+    purple: "brand"
+  };
+  if (named[trimmed]) return named[trimmed];
+  const hexMatch = /^#?([0-9a-f]{6})$/i.exec(trimmed);
+  if (!hexMatch) return void 0;
+  const hex = hexMatch[1];
+  const r = parseInt(hex.slice(0, 2), 16);
+  const g = parseInt(hex.slice(2, 4), 16);
+  const b = parseInt(hex.slice(4, 6), 16);
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const delta = max - min;
+  if (delta < 24) return "neutral";
+  let hue = 0;
+  if (max === r) hue = (g - b) / delta % 6;
+  else if (max === g) hue = (b - r) / delta + 2;
+  else hue = (r - g) / delta + 4;
+  hue = (hue * 60 + 360) % 360;
+  if (hue < 20) return "error";
+  if (hue < 50) return "warning";
+  if (hue < 80) return "warning";
+  if (hue < 170) return "success";
+  if (hue < 260) return "info";
+  if (hue < 320) return "brand";
+  if (hue < 340) return "pink";
+  return "error";
+}
 export {
   OPERATORS_BY_FIELD_TYPE,
   convertAdvancedFilterToWhere,
   createEmptyCondition,
   deserializeAdvancedFilter,
+  deserializeTree,
+  flatToTree,
   getDefaultOperator,
+  isAdvancedFilterState,
   isValidOperator,
   isValuelessOperator,
+  mapDictionaryColorToTone,
   normalizeAdvancedFilterState,
-  serializeAdvancedFilter
+  serializeAdvancedFilter,
+  serializeTree
 };
 //# sourceMappingURL=advanced-filter.js.map