@platforma-sdk/model 1.58.3 → 1.58.9

package/dist/filters/converters/filterToQuery.cjs

@@ -1,250 +1,284 @@
-'use strict';
-
-var plModelCommon = require('@milaboratories/pl-model-common');
-var traverse = require('../traverse.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+const require_traverse = require('../traverse.cjs');
+let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
 
+//#region src/filters/converters/filterToQuery.ts
 /** Parses a CanonicalizedJson<PTableColumnId> string into a SpecQueryExpression reference. */
 function resolveColumnRef(columnStr) {
-    const parsed = JSON.parse(columnStr);
-    return parsed.type === "axis"
-        ? { type: "axisRef", value: parsed.id }
-        : { type: "columnRef", value: parsed.id };
+	const parsed = JSON.parse(columnStr);
+	return parsed.type === "axis" ? {
+		type: "axisRef",
+		value: parsed.id
+	} : {
+		type: "columnRef",
+		value: parsed.id
+	};
 }
 /** Converts a FilterSpec tree into a SpecQueryExpression. */
 function filterSpecToSpecQueryExpr(filter) {
-    return traverse.traverseFilterSpec(filter, {
-        leaf: leafToSpecQueryExpr,
-        and: (inputs) => {
-            if (inputs.length === 0) {
-                throw new Error("AND filter requires at least one operand");
-            }
-            return { type: "and", input: inputs };
-        },
-        or: (inputs) => {
-            if (inputs.length === 0) {
-                throw new Error("OR filter requires at least one operand");
-            }
-            return { type: "or", input: inputs };
-        },
-        not: (input) => ({ type: "not", input }),
-    });
+	return require_traverse.traverseFilterSpec(filter, {
+		leaf: leafToSpecQueryExpr,
+		and: (inputs) => {
+			if (inputs.length === 0) throw new Error("AND filter requires at least one operand");
+			return {
+				type: "and",
+				input: inputs
+			};
+		},
+		or: (inputs) => {
+			if (inputs.length === 0) throw new Error("OR filter requires at least one operand");
+			return {
+				type: "or",
+				input: inputs
+			};
+		},
+		not: (input) => ({
+			type: "not",
+			input
+		})
+	});
 }
 function leafToSpecQueryExpr(filter) {
-    switch (filter.type) {
-        case "patternEquals":
-            return {
-                type: "stringEquals",
-                input: resolveColumnRef(filter.column),
-                value: filter.value,
-                caseInsensitive: false,
-            };
-        case "patternNotEquals":
-            return {
-                type: "not",
-                input: {
-                    type: "stringEquals",
-                    input: resolveColumnRef(filter.column),
-                    value: filter.value,
-                    caseInsensitive: false,
-                },
-            };
-        case "patternContainSubsequence":
-            return {
-                type: "stringContains",
-                input: resolveColumnRef(filter.column),
-                value: filter.value,
-                caseInsensitive: false,
-            };
-        case "patternNotContainSubsequence":
-            return {
-                type: "not",
-                input: {
-                    type: "stringContains",
-                    input: resolveColumnRef(filter.column),
-                    value: filter.value,
-                    caseInsensitive: false,
-                },
-            };
-        case "patternMatchesRegularExpression":
-            return {
-                type: "stringRegex",
-                input: resolveColumnRef(filter.column),
-                value: filter.value,
-            };
-        case "patternFuzzyContainSubsequence":
-            return {
-                type: "stringContainsFuzzy",
-                input: resolveColumnRef(filter.column),
-                value: filter.value,
-                maxEdits: filter.maxEdits ?? 1,
-                caseInsensitive: false,
-                substitutionsOnly: filter.substitutionsOnly ?? false,
-                wildcard: filter.wildcard ?? null,
-            };
-        case "equal":
-            return {
-                type: "numericComparison",
-                operand: "eq",
-                left: resolveColumnRef(filter.column),
-                right: { type: "constant", value: filter.x },
-            };
-        case "notEqual":
-            return {
-                type: "numericComparison",
-                operand: "ne",
-                left: resolveColumnRef(filter.column),
-                right: { type: "constant", value: filter.x },
-            };
-        case "lessThan":
-            return {
-                type: "numericComparison",
-                operand: "lt",
-                left: resolveColumnRef(filter.column),
-                right: { type: "constant", value: filter.x },
-            };
-        case "greaterThan":
-            return {
-                type: "numericComparison",
-                operand: "gt",
-                left: resolveColumnRef(filter.column),
-                right: { type: "constant", value: filter.x },
-            };
-        case "lessThanOrEqual":
-            return {
-                type: "numericComparison",
-                operand: "le",
-                left: resolveColumnRef(filter.column),
-                right: { type: "constant", value: filter.x },
-            };
-        case "greaterThanOrEqual":
-            return {
-                type: "numericComparison",
-                operand: "ge",
-                left: resolveColumnRef(filter.column),
-                right: { type: "constant", value: filter.x },
-            };
-        case "equalToColumn":
-            return {
-                type: "numericComparison",
-                operand: "eq",
-                left: resolveColumnRef(filter.column),
-                right: resolveColumnRef(filter.rhs),
-            };
-        case "lessThanColumn": {
-            const left = resolveColumnRef(filter.column);
-            const right = resolveColumnRef(filter.rhs);
-            if (filter.minDiff !== undefined && filter.minDiff !== 0) {
-                return {
-                    type: "numericComparison",
-                    operand: "lt",
-                    left: {
-                        type: "numericBinary",
-                        operand: "add",
-                        left,
-                        right: { type: "constant", value: filter.minDiff },
-                    },
-                    right,
-                };
-            }
-            return { type: "numericComparison", operand: "lt", left, right };
-        }
-        case "greaterThanColumn": {
-            const left = resolveColumnRef(filter.column);
-            const right = resolveColumnRef(filter.rhs);
-            if (filter.minDiff !== undefined && filter.minDiff !== 0) {
-                return {
-                    type: "numericComparison",
-                    operand: "gt",
-                    left: {
-                        type: "numericBinary",
-                        operand: "add",
-                        left,
-                        right: { type: "constant", value: filter.minDiff },
-                    },
-                    right,
-                };
-            }
-            return { type: "numericComparison", operand: "gt", left, right };
-        }
-        case "lessThanColumnOrEqual": {
-            const left = resolveColumnRef(filter.column);
-            const right = resolveColumnRef(filter.rhs);
-            if (filter.minDiff !== undefined && filter.minDiff !== 0) {
-                return {
-                    type: "numericComparison",
-                    operand: "le",
-                    left: {
-                        type: "numericBinary",
-                        operand: "add",
-                        left,
-                        right: { type: "constant", value: filter.minDiff },
-                    },
-                    right,
-                };
-            }
-            return { type: "numericComparison", operand: "le", left, right };
-        }
-        case "greaterThanColumnOrEqual": {
-            const left = resolveColumnRef(filter.column);
-            const right = resolveColumnRef(filter.rhs);
-            if (filter.minDiff !== undefined && filter.minDiff !== 0) {
-                return {
-                    type: "numericComparison",
-                    operand: "ge",
-                    left: {
-                        type: "numericBinary",
-                        operand: "add",
-                        left,
-                        right: { type: "constant", value: filter.minDiff },
-                    },
-                    right,
-                };
-            }
-            return { type: "numericComparison", operand: "ge", left, right };
-        }
-        case "inSet":
-            return {
-                type: "isIn",
-                input: resolveColumnRef(filter.column),
-                set: filter.value,
-            };
-        case "notInSet":
-            return {
-                type: "not",
-                input: {
-                    type: "isIn",
-                    input: resolveColumnRef(filter.column),
-                    set: filter.value,
-                },
-            };
-        case "isNA":
-            return {
-                type: "isNull",
-                input: resolveColumnRef(filter.column),
-            };
-        case "isNotNA":
-            return {
-                type: "not",
-                input: {
-                    type: "isNull",
-                    input: resolveColumnRef(filter.column),
-                },
-            };
-        case "ifNa":
-            return {
-                type: "ifNull",
-                input: resolveColumnRef(filter.column),
-                replacement: { type: "constant", value: filter.replacement },
-            };
-        case "topN":
-        case "bottomN":
-            throw new Error(`Filter type "${filter.type}" is not supported in query expressions`);
-        case undefined:
-            throw new Error("Filter type is undefined");
-        default:
-            plModelCommon.assertNever(filter);
-    }
+	switch (filter.type) {
+		case "patternEquals": return {
+			type: "stringEquals",
+			input: resolveColumnRef(filter.column),
+			value: filter.value,
+			caseInsensitive: false
+		};
+		case "patternNotEquals": return {
+			type: "not",
+			input: {
+				type: "stringEquals",
+				input: resolveColumnRef(filter.column),
+				value: filter.value,
+				caseInsensitive: false
+			}
+		};
+		case "patternContainSubsequence": return {
+			type: "stringContains",
+			input: resolveColumnRef(filter.column),
+			value: filter.value,
+			caseInsensitive: false
+		};
+		case "patternNotContainSubsequence": return {
+			type: "not",
+			input: {
+				type: "stringContains",
+				input: resolveColumnRef(filter.column),
+				value: filter.value,
+				caseInsensitive: false
+			}
+		};
+		case "patternMatchesRegularExpression": return {
+			type: "stringRegex",
+			input: resolveColumnRef(filter.column),
+			value: filter.value
+		};
+		case "patternFuzzyContainSubsequence": return {
+			type: "stringContainsFuzzy",
+			input: resolveColumnRef(filter.column),
+			value: filter.value,
+			maxEdits: filter.maxEdits ?? 1,
+			caseInsensitive: false,
+			substitutionsOnly: filter.substitutionsOnly ?? false,
+			wildcard: filter.wildcard ?? null
+		};
+		case "equal": return {
+			type: "numericComparison",
+			operand: "eq",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "notEqual": return {
+			type: "numericComparison",
+			operand: "ne",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "lessThan": return {
+			type: "numericComparison",
+			operand: "lt",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "greaterThan": return {
+			type: "numericComparison",
+			operand: "gt",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "lessThanOrEqual": return {
+			type: "numericComparison",
+			operand: "le",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "greaterThanOrEqual": return {
+			type: "numericComparison",
+			operand: "ge",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "equalToColumn": return {
+			type: "numericComparison",
+			operand: "eq",
+			left: resolveColumnRef(filter.column),
+			right: resolveColumnRef(filter.rhs)
+		};
+		case "lessThanColumn": {
+			const left = resolveColumnRef(filter.column);
+			const right = resolveColumnRef(filter.rhs);
+			if (filter.minDiff !== void 0 && filter.minDiff !== 0) return {
+				type: "numericComparison",
+				operand: "lt",
+				left: {
+					type: "numericBinary",
+					operand: "add",
+					left,
+					right: {
+						type: "constant",
+						value: filter.minDiff
+					}
+				},
+				right
+			};
+			return {
+				type: "numericComparison",
+				operand: "lt",
+				left,
+				right
+			};
+		}
+		case "greaterThanColumn": {
+			const left = resolveColumnRef(filter.column);
+			const right = resolveColumnRef(filter.rhs);
+			if (filter.minDiff !== void 0 && filter.minDiff !== 0) return {
+				type: "numericComparison",
+				operand: "gt",
+				left: {
+					type: "numericBinary",
+					operand: "add",
+					left,
+					right: {
+						type: "constant",
+						value: filter.minDiff
+					}
+				},
+				right
+			};
+			return {
+				type: "numericComparison",
+				operand: "gt",
+				left,
+				right
+			};
+		}
+		case "lessThanColumnOrEqual": {
+			const left = resolveColumnRef(filter.column);
+			const right = resolveColumnRef(filter.rhs);
+			if (filter.minDiff !== void 0 && filter.minDiff !== 0) return {
+				type: "numericComparison",
+				operand: "le",
+				left: {
+					type: "numericBinary",
+					operand: "add",
+					left,
+					right: {
+						type: "constant",
+						value: filter.minDiff
+					}
+				},
+				right
+			};
+			return {
+				type: "numericComparison",
+				operand: "le",
+				left,
+				right
+			};
+		}
+		case "greaterThanColumnOrEqual": {
+			const left = resolveColumnRef(filter.column);
+			const right = resolveColumnRef(filter.rhs);
+			if (filter.minDiff !== void 0 && filter.minDiff !== 0) return {
+				type: "numericComparison",
+				operand: "ge",
+				left: {
+					type: "numericBinary",
+					operand: "add",
+					left,
+					right: {
+						type: "constant",
+						value: filter.minDiff
+					}
+				},
+				right
+			};
+			return {
+				type: "numericComparison",
+				operand: "ge",
+				left,
+				right
+			};
+		}
+		case "inSet": return {
+			type: "isIn",
+			input: resolveColumnRef(filter.column),
+			set: filter.value
+		};
+		case "notInSet": return {
+			type: "not",
+			input: {
+				type: "isIn",
+				input: resolveColumnRef(filter.column),
+				set: filter.value
+			}
+		};
+		case "isNA": return {
+			type: "isNull",
+			input: resolveColumnRef(filter.column)
+		};
+		case "isNotNA": return {
+			type: "not",
+			input: {
+				type: "isNull",
+				input: resolveColumnRef(filter.column)
+			}
+		};
+		case "ifNa": return {
+			type: "ifNull",
+			input: resolveColumnRef(filter.column),
+			replacement: {
+				type: "constant",
+				value: filter.replacement
+			}
+		};
+		case "topN":
+		case "bottomN": throw new Error(`Filter type "${filter.type}" is not supported in query expressions`);
+		case void 0: throw new Error("Filter type is undefined");
+		default: (0, _milaboratories_pl_model_common.assertNever)(filter);
+	}
 }
 
+//#endregion
 exports.filterSpecToSpecQueryExpr = filterSpecToSpecQueryExpr;
-//# sourceMappingURL=filterToQuery.cjs.map
+//# sourceMappingURL=filterToQuery.cjs.map

package/dist/filters/converters/filterToQuery.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"filterToQuery.cjs","sources":["../../../src/filters/converters/filterToQuery.ts"],"sourcesContent":["import { assertNever } from \"@milaboratories/pl-model-common\";\nimport type {\n  FilterSpec,\n  FilterSpecLeaf,\n  PTableColumnId,\n  SingleAxisSelector,\n  SpecQueryExpression,\n} from \"@milaboratories/pl-model-common\";\nimport { traverseFilterSpec } from \"../traverse\";\n\n/** Parses a CanonicalizedJson<PTableColumnId> string into a SpecQueryExpression reference. */\nfunction resolveColumnRef(columnStr: string): SpecQueryExpression {\n  const parsed = JSON.parse(columnStr) as PTableColumnId;\n  return parsed.type === \"axis\"\n    ? { type: \"axisRef\", value: parsed.id as SingleAxisSelector }\n    : { type: \"columnRef\", value: parsed.id };\n}\n\n/** Converts a FilterSpec tree into a SpecQueryExpression. */\nexport function filterSpecToSpecQueryExpr<Leaf extends FilterSpecLeaf<string>>(\n  filter: FilterSpec<Leaf>,\n): SpecQueryExpression {\n  return traverseFilterSpec(filter, {\n    leaf: leafToSpecQueryExpr,\n    and: (inputs) => {\n      if (inputs.length === 0) {\n        throw new Error(\"AND filter requires at least one operand\");\n      }\n      return { type: \"and\", input: inputs };\n    },\n    or: (inputs) => {\n      if (inputs.length === 0) {\n        throw new Error(\"OR filter requires at least one operand\");\n      }\n      return { type: \"or\", input: inputs };\n    },\n    not: (input) => ({ type: \"not\", input }),\n  });\n}\n\nfunction leafToSpecQueryExpr<Leaf extends FilterSpecLeaf<string>>(\n  filter: Leaf,\n): SpecQueryExpression {\n  switch (filter.type) {\n    case \"patternEquals\":\n      return {\n        type: \"stringEquals\",\n        input: resolveColumnRef(filter.column),\n        value: filter.value,\n        caseInsensitive: false,\n      };\n    case \"patternNotEquals\":\n      return {\n        type: \"not\",\n        input: {\n          type: \"stringEquals\",\n          input: resolveColumnRef(filter.column),\n          value: filter.value,\n          caseInsensitive: false,\n        },\n      };\n    case \"patternContainSubsequence\":\n      return {\n        type: \"stringContains\",\n        input: resolveColumnRef(filter.column),\n        value: filter.value,\n        caseInsensitive: false,\n      };\n    case \"patternNotContainSubsequence\":\n      return {\n        type: \"not\",\n        input: {\n          type: \"stringContains\",\n          input: resolveColumnRef(filter.column),\n          value: filter.value,\n          caseInsensitive: false,\n        },\n      };\n    case \"patternMatchesRegularExpression\":\n      return {\n        type: \"stringRegex\",\n        input: resolveColumnRef(filter.column),\n        value: filter.value,\n      };\n    case \"patternFuzzyContainSubsequence\":\n      return {\n        type: \"stringContainsFuzzy\",\n        input: resolveColumnRef(filter.column),\n        value: filter.value,\n        maxEdits: filter.maxEdits ?? 1,\n        caseInsensitive: false,\n        substitutionsOnly: filter.substitutionsOnly ?? false,\n        wildcard: filter.wildcard ?? null,\n      };\n\n    case \"equal\":\n      return {\n        type: \"numericComparison\",\n        operand: \"eq\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n    case \"notEqual\":\n      return {\n        type: \"numericComparison\",\n        operand: \"ne\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n    case \"lessThan\":\n      return {\n        type: \"numericComparison\",\n        operand: \"lt\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n    case \"greaterThan\":\n      return {\n        type: \"numericComparison\",\n        operand: \"gt\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n    case \"lessThanOrEqual\":\n      return {\n        type: \"numericComparison\",\n        operand: \"le\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n    case \"greaterThanOrEqual\":\n      return {\n        type: \"numericComparison\",\n        operand: \"ge\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n\n    case \"equalToColumn\":\n      return {\n        type: \"numericComparison\",\n        operand: \"eq\",\n        left: resolveColumnRef(filter.column),\n        right: resolveColumnRef(filter.rhs),\n      };\n    case \"lessThanColumn\": {\n      const left = resolveColumnRef(filter.column);\n      const right = resolveColumnRef(filter.rhs);\n      if (filter.minDiff !== undefined && filter.minDiff !== 0) {\n        return {\n          type: \"numericComparison\",\n          operand: \"lt\",\n          left: {\n            type: \"numericBinary\",\n            operand: \"add\",\n            left,\n            right: { type: \"constant\", value: filter.minDiff },\n          },\n          right,\n        };\n      }\n      return { type: \"numericComparison\", operand: \"lt\", left, right };\n    }\n    case \"greaterThanColumn\": {\n      const left = resolveColumnRef(filter.column);\n      const right = resolveColumnRef(filter.rhs);\n      if (filter.minDiff !== undefined && filter.minDiff !== 0) {\n        return {\n          type: \"numericComparison\",\n          operand: \"gt\",\n          left: {\n            type: \"numericBinary\",\n            operand: \"add\",\n            left,\n            right: { type: \"constant\", value: filter.minDiff },\n          },\n          right,\n        };\n      }\n      return { type: \"numericComparison\", operand: \"gt\", left, right };\n    }\n    case \"lessThanColumnOrEqual\": {\n      const left = resolveColumnRef(filter.column);\n      const right = resolveColumnRef(filter.rhs);\n      if (filter.minDiff !== undefined && filter.minDiff !== 0) {\n        return {\n          type: \"numericComparison\",\n          operand: \"le\",\n          left: {\n            type: \"numericBinary\",\n            operand: \"add\",\n            left,\n            right: { type: \"constant\", value: filter.minDiff },\n          },\n          right,\n        };\n      }\n      return { type: \"numericComparison\", operand: \"le\", left, right };\n    }\n    case \"greaterThanColumnOrEqual\": {\n      const left = resolveColumnRef(filter.column);\n      const right = resolveColumnRef(filter.rhs);\n      if (filter.minDiff !== undefined && filter.minDiff !== 0) {\n        return {\n          type: \"numericComparison\",\n          operand: \"ge\",\n          left: {\n            type: \"numericBinary\",\n            operand: \"add\",\n            left,\n            right: { type: \"constant\", value: filter.minDiff },\n          },\n          right,\n        };\n      }\n      return { type: \"numericComparison\", operand: \"ge\", left, right };\n    }\n\n    case \"inSet\":\n      return {\n        type: \"isIn\",\n        input: resolveColumnRef(filter.column),\n        set: filter.value,\n      };\n    case \"notInSet\":\n      return {\n        type: \"not\",\n        input: {\n          type: \"isIn\",\n          input: resolveColumnRef(filter.column),\n          set: filter.value,\n        },\n      };\n\n    case \"isNA\":\n      return {\n        type: \"isNull\",\n        input: resolveColumnRef(filter.column),\n      };\n    case \"isNotNA\":\n      return {\n        type: \"not\",\n        input: {\n          type: \"isNull\",\n          input: resolveColumnRef(filter.column),\n        },\n      };\n\n    case \"ifNa\":\n      return {\n        type: \"ifNull\",\n        input: resolveColumnRef(filter.column),\n        replacement: { type: \"constant\", value: filter.replacement },\n      };\n\n    case \"topN\":\n    case \"bottomN\":\n      throw new Error(`Filter type \"${filter.type}\" is not supported in query expressions`);\n\n    case undefined:\n      throw new Error(\"Filter type is undefined\");\n\n    default:\n      assertNever(filter);\n  }\n}\n"],"names":["traverseFilterSpec","assertNever"],"mappings":"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"}
+{"version":3,"file":"filterToQuery.cjs","names":["traverseFilterSpec"],"sources":["../../../src/filters/converters/filterToQuery.ts"],"sourcesContent":["import { assertNever } from \"@milaboratories/pl-model-common\";\nimport type {\n  FilterSpec,\n  FilterSpecLeaf,\n  PTableColumnId,\n  SingleAxisSelector,\n  SpecQueryExpression,\n} from \"@milaboratories/pl-model-common\";\nimport { traverseFilterSpec } from \"../traverse\";\n\n/** Parses a CanonicalizedJson<PTableColumnId> string into a SpecQueryExpression reference. */\nfunction resolveColumnRef(columnStr: string): SpecQueryExpression {\n  const parsed = JSON.parse(columnStr) as PTableColumnId;\n  return parsed.type === \"axis\"\n    ? { type: \"axisRef\", value: parsed.id as SingleAxisSelector }\n    : { type: \"columnRef\", value: parsed.id };\n}\n\n/** Converts a FilterSpec tree into a SpecQueryExpression. */\nexport function filterSpecToSpecQueryExpr<Leaf extends FilterSpecLeaf<string>>(\n  filter: FilterSpec<Leaf>,\n): SpecQueryExpression {\n  return traverseFilterSpec(filter, {\n    leaf: leafToSpecQueryExpr,\n    and: (inputs) => {\n      if (inputs.length === 0) {\n        throw new Error(\"AND filter requires at least one operand\");\n      }\n      return { type: \"and\", input: inputs };\n    },\n    or: (inputs) => {\n      if (inputs.length === 0) {\n        throw new Error(\"OR filter requires at least one operand\");\n      }\n      return { type: \"or\", input: inputs };\n    },\n    not: (input) => ({ type: \"not\", input }),\n  });\n}\n\nfunction leafToSpecQueryExpr<Leaf extends FilterSpecLeaf<string>>(\n  filter: Leaf,\n): SpecQueryExpression {\n  switch (filter.type) {\n    case \"patternEquals\":\n      return {\n        type: \"stringEquals\",\n        input: resolveColumnRef(filter.column),\n        value: filter.value,\n        caseInsensitive: false,\n      };\n    case \"patternNotEquals\":\n      return {\n        type: \"not\",\n        input: {\n          type: \"stringEquals\",\n          input: resolveColumnRef(filter.column),\n          value: filter.value,\n          caseInsensitive: false,\n        },\n      };\n    case \"patternContainSubsequence\":\n      return {\n        type: \"stringContains\",\n        input: resolveColumnRef(filter.column),\n        value: filter.value,\n        caseInsensitive: false,\n      };\n    case \"patternNotContainSubsequence\":\n      return {\n        type: \"not\",\n        input: {\n          type: \"stringContains\",\n          input: resolveColumnRef(filter.column),\n          value: filter.value,\n          caseInsensitive: false,\n        },\n      };\n    case \"patternMatchesRegularExpression\":\n      return {\n        type: \"stringRegex\",\n        input: resolveColumnRef(filter.column),\n        value: filter.value,\n      };\n    case \"patternFuzzyContainSubsequence\":\n      return {\n        type: \"stringContainsFuzzy\",\n        input: resolveColumnRef(filter.column),\n        value: filter.value,\n        maxEdits: filter.maxEdits ?? 1,\n        caseInsensitive: false,\n        substitutionsOnly: filter.substitutionsOnly ?? false,\n        wildcard: filter.wildcard ?? null,\n      };\n\n    case \"equal\":\n      return {\n        type: \"numericComparison\",\n        operand: \"eq\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n    case \"notEqual\":\n      return {\n        type: \"numericComparison\",\n        operand: \"ne\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n    case \"lessThan\":\n      return {\n        type: \"numericComparison\",\n        operand: \"lt\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n    case \"greaterThan\":\n      return {\n        type: \"numericComparison\",\n        operand: \"gt\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n    case \"lessThanOrEqual\":\n      return {\n        type: \"numericComparison\",\n        operand: \"le\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n    case \"greaterThanOrEqual\":\n      return {\n        type: \"numericComparison\",\n        operand: \"ge\",\n        left: resolveColumnRef(filter.column),\n        right: { type: \"constant\", value: filter.x },\n      };\n\n    case \"equalToColumn\":\n      return {\n        type: \"numericComparison\",\n        operand: \"eq\",\n        left: resolveColumnRef(filter.column),\n        right: resolveColumnRef(filter.rhs),\n      };\n    case \"lessThanColumn\": {\n      const left = resolveColumnRef(filter.column);\n      const right = resolveColumnRef(filter.rhs);\n      if (filter.minDiff !== undefined && filter.minDiff !== 0) {\n        return {\n          type: \"numericComparison\",\n          operand: \"lt\",\n          left: {\n            type: \"numericBinary\",\n            operand: \"add\",\n            left,\n            right: { type: \"constant\", value: filter.minDiff },\n          },\n          right,\n        };\n      }\n      return { type: \"numericComparison\", operand: \"lt\", left, right };\n    }\n    case \"greaterThanColumn\": {\n      const left = resolveColumnRef(filter.column);\n      const right = resolveColumnRef(filter.rhs);\n      if (filter.minDiff !== undefined && filter.minDiff !== 0) {\n        return {\n          type: \"numericComparison\",\n          operand: \"gt\",\n          left: {\n            type: \"numericBinary\",\n            operand: \"add\",\n            left,\n            right: { type: \"constant\", value: filter.minDiff },\n          },\n          right,\n        };\n      }\n      return { type: \"numericComparison\", operand: \"gt\", left, right };\n    }\n    case \"lessThanColumnOrEqual\": {\n      const left = resolveColumnRef(filter.column);\n      const right = resolveColumnRef(filter.rhs);\n      if (filter.minDiff !== undefined && filter.minDiff !== 0) {\n        return {\n          type: \"numericComparison\",\n          operand: \"le\",\n          left: {\n            type: \"numericBinary\",\n            operand: \"add\",\n            left,\n            right: { type: \"constant\", value: filter.minDiff },\n          },\n          right,\n        };\n      }\n      return { type: \"numericComparison\", operand: \"le\", left, right };\n    }\n    case \"greaterThanColumnOrEqual\": {\n      const left = resolveColumnRef(filter.column);\n      const right = resolveColumnRef(filter.rhs);\n      if (filter.minDiff !== undefined && filter.minDiff !== 0) {\n        return {\n          type: \"numericComparison\",\n          operand: \"ge\",\n          left: {\n            type: \"numericBinary\",\n            operand: \"add\",\n            left,\n            right: { type: \"constant\", value: filter.minDiff },\n          },\n          right,\n        };\n      }\n      return { type: \"numericComparison\", operand: \"ge\", left, right };\n    }\n\n    case \"inSet\":\n      return {\n        type: \"isIn\",\n        input: resolveColumnRef(filter.column),\n        set: filter.value,\n      };\n    case \"notInSet\":\n      return {\n        type: \"not\",\n        input: {\n          type: \"isIn\",\n          input: resolveColumnRef(filter.column),\n          set: filter.value,\n        },\n      };\n\n    case \"isNA\":\n      return {\n        type: \"isNull\",\n        input: resolveColumnRef(filter.column),\n      };\n    case \"isNotNA\":\n      return {\n        type: \"not\",\n        input: {\n          type: \"isNull\",\n          input: resolveColumnRef(filter.column),\n        },\n      };\n\n    case \"ifNa\":\n      return {\n        type: \"ifNull\",\n        input: resolveColumnRef(filter.column),\n        replacement: { type: \"constant\", value: filter.replacement },\n      };\n\n    case \"topN\":\n    case \"bottomN\":\n      throw new Error(`Filter type \"${filter.type}\" is not supported in query expressions`);\n\n    case undefined:\n      throw new Error(\"Filter type is undefined\");\n\n    default:\n      assertNever(filter);\n  }\n}\n"],"mappings":"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"}

package/dist/filters/converters/filterToQuery.d.ts

@@ -1,4 +1,8 @@
-import type { FilterSpec, FilterSpecLeaf, SpecQueryExpression } from "@milaboratories/pl-model-common";
+import { FilterSpec, FilterSpecLeaf, SpecQueryExpression } from "@milaboratories/pl-model-common";
+
+//#region src/filters/converters/filterToQuery.d.ts
 /** Converts a FilterSpec tree into a SpecQueryExpression. */
-export declare function filterSpecToSpecQueryExpr<Leaf extends FilterSpecLeaf<string>>(filter: FilterSpec<Leaf>): SpecQueryExpression;
+declare function filterSpecToSpecQueryExpr<Leaf extends FilterSpecLeaf<string>>(filter: FilterSpec<Leaf>): SpecQueryExpression;
+//#endregion
+export { filterSpecToSpecQueryExpr };
 //# sourceMappingURL=filterToQuery.d.ts.map