{"version":3,"file":"traverse.cjs","names":[],"sources":["../../src/filters/traverse.ts"],"sourcesContent":["import type {\n  FilterSpec,\n  FilterSpecLeaf,\n  FilterSpecNode,\n  InferFilterSpecLeafColumn,\n} from \"@milaboratories/pl-model-common\";\nimport type {\n  InferFilterSpecCommonLeaf,\n  InferFilterSpecLeaf,\n} from \"@milaboratories/pl-model-common\";\n\nexport type FilterSpecVisitor<LeafArg, R> = {\n  /** Handle a leaf filter node. */\n  leaf: (leaf: LeafArg) => R;\n  /** Handle an AND node after children have been traversed. */\n  and: (results: R[]) => R;\n  /** Handle an OR node after children have been traversed. */\n  or: (results: R[]) => R;\n  /** Handle a NOT node after the inner filter has been traversed. */\n  not: (result: R) => R;\n};\n\n/**\n * Recursively traverses a FilterSpec tree bottom-up, applying visitor callbacks.\n *\n * Entries with `{ type: undefined }` inside `and`/`or` arrays are skipped\n * (these represent unfilled filter slots in the UI).\n *\n * Traversal order:\n * 1. Recurse into child filters (`and`/`or`/`not`)\n * 2. Apply the corresponding visitor callback with already-traversed children\n * 3. For leaf nodes, call `leaf` directly\n */\nexport function traverseFilterSpec<\n  F extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>,\n  R,\n>(\n  filter: F,\n  visitor: FilterSpecVisitor<InferFilterSpecCommonLeaf<F> & InferFilterSpecLeaf<F>, R>,\n): R {\n  return traverseFilterSpecImpl(filter, visitor as FilterSpecVisitor<unknown, R>);\n}\n/** Internal implementation with simple generics for clean recursion. */\nfunction traverseFilterSpecImpl<R>(\n  filter: FilterSpecNode<FilterSpecLeaf<unknown>, unknown, unknown>,\n  visitor: FilterSpecVisitor<unknown, R>,\n): R {\n  switch (filter.type) {\n    case \"and\":\n      return visitor.and(\n        filter.filters\n          .filter((f) => f.type !== undefined)\n          .map((f) => traverseFilterSpecImpl(f, visitor)),\n      );\n    case \"or\":\n      return visitor.or(\n        filter.filters\n          .filter((f) => f.type !== undefined)\n          .map((f) => traverseFilterSpecImpl(f, visitor)),\n      );\n    case \"not\":\n      return visitor.not(traverseFilterSpecImpl(filter.filter, visitor));\n    default:\n      return visitor.leaf(filter);\n  }\n}\n\n/** Collects all column references (`column` and `rhs` fields) from filter leaves. */\nexport function collectFilterSpecColumns<\n  F extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>,\n  R extends InferFilterSpecLeafColumn<F> = InferFilterSpecLeafColumn<F>,\n>(filter: F): R[] {\n  return traverseFilterSpec(filter, {\n    leaf: (leaf) => {\n      const cols: R[] = [];\n      if (\"column\" in leaf && leaf.column !== undefined) cols.push(leaf.column as R);\n      if (\"rhs\" in leaf && leaf.rhs !== undefined) cols.push(leaf.rhs as R);\n      return cols;\n    },\n    and: (results) => results.flat(),\n    or: (results) => results.flat(),\n    not: (result) => result,\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAiCA,SAAgB,mBAId,QACA,SACG;CACH,OAAO,uBAAuB,QAAQ,OAAwC;AAChF;;AAEA,SAAS,uBACP,QACA,SACG;CACH,QAAQ,OAAO,MAAf;EACE,KAAK,OACH,OAAO,QAAQ,IACb,OAAO,QACJ,QAAQ,MAAM,EAAE,SAAS,KAAA,CAAS,CAAC,CACnC,KAAK,MAAM,uBAAuB,GAAG,OAAO,CAAC,CAClD;EACF,KAAK,MACH,OAAO,QAAQ,GACb,OAAO,QACJ,QAAQ,MAAM,EAAE,SAAS,KAAA,CAAS,CAAC,CACnC,KAAK,MAAM,uBAAuB,GAAG,OAAO,CAAC,CAClD;EACF,KAAK,OACH,OAAO,QAAQ,IAAI,uBAAuB,OAAO,QAAQ,OAAO,CAAC;EACnE,SACE,OAAO,QAAQ,KAAK,MAAM;CAC9B;AACF;;AAGA,SAAgB,yBAGd,QAAgB;CAChB,OAAO,mBAAmB,QAAQ;EAChC,OAAO,SAAS;GACd,MAAM,OAAY,CAAC;GACnB,IAAI,YAAY,QAAQ,KAAK,WAAW,KAAA,GAAW,KAAK,KAAK,KAAK,MAAW;GAC7E,IAAI,SAAS,QAAQ,KAAK,QAAQ,KAAA,GAAW,KAAK,KAAK,KAAK,GAAQ;GACpE,OAAO;EACT;EACA,MAAM,YAAY,QAAQ,KAAK;EAC/B,KAAK,YAAY,QAAQ,KAAK;EAC9B,MAAM,WAAW;CACnB,CAAC;AACH"}