@burdenoff/fluidgrids-fe-sdk 2026.1113.1 → 2026.1113.2

package/dist/conditionBuilder-D8aLGL1w.js

@@ -0,0 +1,1134 @@
+"use client";
+import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useReactFlow } from "@xyflow/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { toast } from "sonner";
+import { Badge, Button, Card, CardContent, CardDescription, CardHeader, CardTitle, Input, Label, ScrollArea, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, Tabs, TabsContent, TabsList, TabsTrigger, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@burdenoff/fe-libs/ui";
+import { AlertCircle, ChevronDown, ChevronRight, Copy, Info, Layers, Plus, Trash2 } from "lucide-react";
+
+// src/builder/components/flow-builder/components/edges/conditionBuilder/custom-condition-edge.tsx
+const OPERATORS = {
+	string: [
+		{
+			value: "==",
+			label: "Equals"
+		},
+		{
+			value: "contains",
+			label: "Contains"
+		},
+		{
+			value: "startsWith",
+			label: "Starts with"
+		},
+		{
+			value: "endsWith",
+			label: "Ends with"
+		},
+		{
+			value: "isNull",
+			label: "Is Null"
+		},
+		{
+			value: "isNotNull",
+			label: "Is Not Null"
+		}
+	],
+	number: [
+		{
+			value: "==",
+			label: "Equals"
+		},
+		{
+			value: "!=",
+			label: "Not equals"
+		},
+		{
+			value: ">",
+			label: "Greater than"
+		},
+		{
+			value: ">=",
+			label: "Greater than or equal"
+		},
+		{
+			value: "<",
+			label: "Less than"
+		},
+		{
+			value: "<=",
+			label: "Less than or equal"
+		},
+		{
+			value: "isNull",
+			label: "Is Null"
+		},
+		{
+			value: "isNotNull",
+			label: "Is Not Null"
+		}
+	],
+	integer: [
+		{
+			value: "==",
+			label: "Equals"
+		},
+		{
+			value: "!=",
+			label: "Not equals"
+		},
+		{
+			value: ">",
+			label: "Greater than"
+		},
+		{
+			value: ">=",
+			label: "Greater than or equal"
+		},
+		{
+			value: "<",
+			label: "Less than"
+		},
+		{
+			value: "<=",
+			label: "Less than or equal"
+		},
+		{
+			value: "isNull",
+			label: "Is Null"
+		},
+		{
+			value: "isNotNull",
+			label: "Is Not Null"
+		}
+	],
+	boolean: [
+		{
+			value: "isTrue",
+			label: "Is True"
+		},
+		{
+			value: "isFalse",
+			label: "Is False"
+		},
+		{
+			value: "isNull",
+			label: "Is Null"
+		},
+		{
+			value: "isNotNull",
+			label: "Is Not Null"
+		}
+	],
+	array: [
+		{
+			value: "isEmpty",
+			label: "Is Empty Array"
+		},
+		{
+			value: "isNotEmpty",
+			label: "Is Not Empty Array"
+		},
+		{
+			value: "contains",
+			label: "Contains Element"
+		},
+		{
+			value: "isNull",
+			label: "Is Null"
+		},
+		{
+			value: "isNotNull",
+			label: "Is Not Null"
+		}
+	],
+	object: [
+		{
+			value: "isEmpty",
+			label: "Is Empty Object"
+		},
+		{
+			value: "isNotEmpty",
+			label: "Is Not Empty Object"
+		},
+		{
+			value: "hasProperty",
+			label: "Has Property"
+		},
+		{
+			value: "isNull",
+			label: "Is Null"
+		},
+		{
+			value: "isNotNull",
+			label: "Is Not Null"
+		}
+	]
+};
+const parseSchema = (schema, currentPath = "", fields = []) => {
+	if (!schema || typeof schema !== "object") return fields;
+	const knownTypes = [
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"array",
+		"object"
+	];
+	if (schema.type === "object" && schema.properties) for (const key in schema.properties) {
+		const property = schema.properties[key];
+		const newPath = currentPath ? `${currentPath}.${key}` : key;
+		if (property?.type && knownTypes.includes(property.type)) fields.push({
+			path: newPath,
+			type: property.type
+		});
+		if (property?.type === "object" && property.properties) parseSchema(property, newPath, fields);
+		if (property?.type === "array" && property.items && property.items.type === "object") {
+			fields.push({
+				path: newPath,
+				type: "array"
+			});
+			if (property.items.properties) for (const itemKey in property.items.properties) {
+				const itemProperty = property.items.properties[itemKey];
+				const itemPath = `${newPath}.${itemKey}`;
+				if (itemProperty?.type && knownTypes.includes(itemProperty.type)) fields.push({
+					path: itemPath,
+					type: itemProperty.type
+				});
+				if (itemProperty?.type === "object" && itemProperty.properties) parseSchema(itemProperty, itemPath, fields);
+			}
+		}
+	}
+	fields.sort((a, b) => a.path.localeCompare(b.path));
+	return Array.from(new Map(fields.map((f) => [f.path, f])).values());
+};
+const getOperatorsForType = (type) => OPERATORS[type] || [{
+	value: "isNull",
+	label: "Is Null"
+}, {
+	value: "isNotNull",
+	label: "Is Not Null"
+}];
+const generateId = () => Date.now().toString(36) + Math.random().toString(36).substring(2);
+const createEmptyGroup = (id) => ({
+	id: id || generateId(),
+	type: "group",
+	combinator: "AND",
+	children: []
+});
+const createEmptyRule = (id) => ({
+	id: id || generateId(),
+	type: "rule",
+	field: "",
+	operator: "",
+	value: ""
+});
+const findAndModifyNode = (node, targetId, modification) => {
+	if (node.id === targetId) return modification(node);
+	if (node.type === "group") {
+		let childrenChanged = false;
+		const newChildren = node.children.map((child) => {
+			const modifiedChild = findAndModifyNode(child, targetId, modification);
+			if (modifiedChild !== child) childrenChanged = true;
+			return modifiedChild;
+		}).filter((child) => child !== null);
+		if (childrenChanged) return {
+			...node,
+			children: newChildren
+		};
+	}
+	return node;
+};
+const findAndAddNode = (node, parentId, nodeToAdd) => {
+	if (node.id === parentId && node.type === "group") return {
+		...node,
+		children: [...node.children, nodeToAdd]
+	};
+	if (node.type === "group") {
+		let childrenChanged = false;
+		const newChildren = node.children.map((child) => {
+			const updatedChild = findAndAddNode(child, parentId, nodeToAdd);
+			if (updatedChild !== child) childrenChanged = true;
+			return updatedChild;
+		});
+		if (childrenChanged) return {
+			...node,
+			children: newChildren
+		};
+	}
+	return node;
+};
+const ConditionNodeDisplay = ({ node, path, fieldMap, parsedFields, onUpdateNode, onRemoveNode, onAddRule, onAddGroup, onDuplicateNode, level }) => {
+	const tr = useTr();
+	const [isExpanded, setIsExpanded] = useState(true);
+	const translateOperatorLabel = (label) => {
+		switch (label) {
+			case "Equals": return tr("fluidgrids.builder.conditionBuilder.operatorEquals", "Equals");
+			case "Not equals": return tr("fluidgrids.builder.conditionBuilder.operatorNotEquals", "Not equals");
+			case "Contains": return tr("fluidgrids.builder.conditionBuilder.operatorContains", "Contains");
+			case "Starts with": return tr("fluidgrids.builder.conditionBuilder.operatorStartsWith", "Starts with");
+			case "Ends with": return tr("fluidgrids.builder.conditionBuilder.operatorEndsWith", "Ends with");
+			case "Greater than": return tr("fluidgrids.builder.conditionBuilder.operatorGreaterThan", "Greater than");
+			case "Greater than or equal": return tr("fluidgrids.builder.conditionBuilder.operatorGreaterThanOrEqual", "Greater than or equal");
+			case "Less than": return tr("fluidgrids.builder.conditionBuilder.operatorLessThan", "Less than");
+			case "Less than or equal": return tr("fluidgrids.builder.conditionBuilder.operatorLessThanOrEqual", "Less than or equal");
+			case "Is True": return tr("fluidgrids.builder.conditionBuilder.operatorIsTrue", "Is True");
+			case "Is False": return tr("fluidgrids.builder.conditionBuilder.operatorIsFalse", "Is False");
+			case "Is Null": return tr("fluidgrids.builder.conditionBuilder.operatorIsNull", "Is Null");
+			case "Is Not Null": return tr("fluidgrids.builder.conditionBuilder.operatorIsNotNull", "Is Not Null");
+			case "Is Empty Array": return tr("fluidgrids.builder.conditionBuilder.operatorIsEmptyArray", "Is Empty Array");
+			case "Is Not Empty Array": return tr("fluidgrids.builder.conditionBuilder.operatorIsNotEmptyArray", "Is Not Empty Array");
+			case "Contains Element": return tr("fluidgrids.builder.conditionBuilder.operatorContainsElement", "Contains Element");
+			case "Is Empty Object": return tr("fluidgrids.builder.conditionBuilder.operatorIsEmptyObject", "Is Empty Object");
+			case "Is Not Empty Object": return tr("fluidgrids.builder.conditionBuilder.operatorIsNotEmptyObject", "Is Not Empty Object");
+			case "Has Property": return tr("fluidgrids.builder.conditionBuilder.operatorHasProperty", "Has Property");
+			default: return label;
+		}
+	};
+	const handleUpdate = useCallback((updates) => {
+		onUpdateNode(node.id, updates);
+	}, [node.id, onUpdateNode]);
+	const handleRemove = useCallback(() => {
+		onRemoveNode(node.id);
+	}, [node.id, onRemoveNode]);
+	const handleDuplicate = useCallback(() => {
+		if (onDuplicateNode) onDuplicateNode(node.id);
+	}, [node.id, onDuplicateNode]);
+	if (node.type === "rule") {
+		const { field, operator, value } = node;
+		const selectedFieldType = fieldMap.get(field);
+		const availableOperators = selectedFieldType ? getOperatorsForType(selectedFieldType) : [];
+		const needsValue = field && operator && ![
+			"isTrue",
+			"isFalse",
+			"isEmpty",
+			"isNotEmpty",
+			"isNull",
+			"isNotNull"
+		].includes(operator);
+		const renderValueInputForRule = () => {
+			if (!needsValue) return null;
+			switch (selectedFieldType) {
+				case "number":
+				case "integer": return /* @__PURE__ */ jsx(Input, {
+					type: "number",
+					placeholder: tr("fluidgrids.builder.conditionBuilder.numberValuePlaceholder", "Number"),
+					value: typeof value === "boolean" ? "" : value ?? "",
+					onChange: (e) => handleUpdate({ value: e.target.value === "" ? null : Number(e.target.value) }),
+					className: "w-full flex-grow"
+				});
+				case "boolean": return /* @__PURE__ */ jsx("span", {
+					className: "text-sm text-muted-foreground italic p-2",
+					children: tr("fluidgrids.builder.conditionBuilder.booleanValueHint", "Use 'Is True' / 'Is False'")
+				});
+				default: return /* @__PURE__ */ jsx(Input, {
+					type: "text",
+					placeholder: tr("fluidgrids.builder.conditionBuilder.textValuePlaceholder", "Value"),
+					value: typeof value === "boolean" ? String(value) : value ?? "",
+					onChange: (e) => handleUpdate({ value: e.target.value }),
+					className: "w-full flex-grow"
+				});
+			}
+		};
+		return /* @__PURE__ */ jsx(Card, {
+			className: "overflow-hidden border-muted-foreground/20 shadow-sm transition-all hover:shadow-md",
+			children: /* @__PURE__ */ jsx(CardContent, {
+				className: "p-3",
+				children: /* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col sm:flex-row items-stretch sm:items-center gap-2",
+					children: [
+						/* @__PURE__ */ jsx("div", {
+							className: "w-full sm:w-[30%]",
+							children: /* @__PURE__ */ jsxs(Select, {
+								value: field,
+								onValueChange: (val) => handleUpdate({
+									field: val,
+									operator: "",
+									value: ""
+								}),
+								children: [/* @__PURE__ */ jsx(SelectTrigger, {
+									className: "h-9",
+									children: /* @__PURE__ */ jsx(SelectValue, { placeholder: tr("fluidgrids.builder.conditionBuilder.selectFieldPlaceholder", "Select field") })
+								}), /* @__PURE__ */ jsx(SelectContent, {
+									className: "max-h-[300px] z-[100000]",
+									children: parsedFields.map((f) => /* @__PURE__ */ jsx(SelectItem, {
+										value: f.path,
+										children: /* @__PURE__ */ jsxs("div", {
+											className: "flex items-center gap-2 w-full",
+											children: [/* @__PURE__ */ jsx("span", {
+												className: "overflow-visible whitespace-normal break-words",
+												children: f.path
+											}), /* @__PURE__ */ jsx(Badge, {
+												variant: "outline",
+												className: "ml-auto shrink-0 text-xs",
+												children: f.type
+											})]
+										})
+									}, f.path))
+								})]
+							})
+						}),
+						/* @__PURE__ */ jsx("div", {
+							className: "w-full sm:w-[25%]",
+							children: /* @__PURE__ */ jsxs(Select, {
+								value: operator,
+								onValueChange: (val) => handleUpdate({
+									operator: val,
+									value: ""
+								}),
+								disabled: !field,
+								children: [/* @__PURE__ */ jsx(SelectTrigger, {
+									className: "h-9",
+									children: /* @__PURE__ */ jsx(SelectValue, { placeholder: tr("fluidgrids.builder.conditionBuilder.operatorPlaceholder", "Operator") })
+								}), /* @__PURE__ */ jsx(SelectContent, {
+									className: "z-[100000]",
+									children: availableOperators.map((op) => /* @__PURE__ */ jsx(SelectItem, {
+										value: op.value,
+										children: translateOperatorLabel(op.label)
+									}, op.value))
+								})]
+							})
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: `w-full ${needsValue ? "sm:w-[35%]" : "sm:w-[25%]"} flex items-center`,
+							children: [renderValueInputForRule(), !needsValue && operator && /* @__PURE__ */ jsx("span", {
+								className: "text-sm text-muted-foreground italic p-2",
+								children: tr("fluidgrids.builder.conditionBuilder.noValueNeeded", "No value needed")
+							})]
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "w-full sm:w-[10%] flex justify-end sm:justify-center gap-1",
+							children: [/* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [/* @__PURE__ */ jsx(TooltipTrigger, {
+								asChild: true,
+								children: /* @__PURE__ */ jsx(Button, {
+									variant: "ghost",
+									size: "icon",
+									onClick: handleDuplicate,
+									className: "h-8 w-8",
+									children: /* @__PURE__ */ jsx(Copy, { className: "h-4 w-4" })
+								})
+							}), /* @__PURE__ */ jsx(TooltipContent, { children: /* @__PURE__ */ jsx("p", { children: tr("fluidgrids.builder.conditionBuilder.duplicateRuleTooltip", "Duplicate rule") }) })] }) }), /* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [/* @__PURE__ */ jsx(TooltipTrigger, {
+								asChild: true,
+								children: /* @__PURE__ */ jsx(Button, {
+									variant: "ghost",
+									size: "icon",
+									onClick: handleRemove,
+									className: "h-8 w-8 text-destructive hover:text-destructive/90 hover:bg-destructive/10",
+									children: /* @__PURE__ */ jsx(Trash2, { className: "h-4 w-4" })
+								})
+							}), /* @__PURE__ */ jsx(TooltipContent, { children: /* @__PURE__ */ jsx("p", { children: tr("fluidgrids.builder.conditionBuilder.removeRuleTooltip", "Remove rule") }) })] }) })]
+						})
+					]
+				})
+			})
+		});
+	}
+	if (node.type === "group") {
+		const { combinator, children } = node;
+		const isRoot = path.length === 1 && path[0] === "root";
+		const hasChildren = children.length > 0;
+		const handleCombinatorChange = (value) => {
+			handleUpdate({ combinator: value });
+		};
+		const handleAddRuleClick = () => onAddRule(node.id);
+		const handleAddGroupClick = () => onAddGroup(node.id);
+		const toggleExpanded = () => setIsExpanded(!isExpanded);
+		const getBgColor = () => {
+			if (isRoot) return "bg-background";
+			return level % 2 === 0 ? "bg-muted/30" : "bg-background";
+		};
+		return /* @__PURE__ */ jsx("div", {
+			className: `rounded-lg border ${isRoot ? "border-primary/30" : "border-muted-foreground/20"} ${getBgColor()} transition-all`,
+			children: /* @__PURE__ */ jsxs("div", {
+				className: "p-3",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2 mb-2",
+					children: [
+						hasChildren && /* @__PURE__ */ jsx(Button, {
+							variant: "ghost",
+							size: "icon",
+							onClick: toggleExpanded,
+							className: "h-7 w-7 p-0",
+							children: isExpanded ? /* @__PURE__ */ jsx(ChevronDown, { className: "h-4 w-4" }) : /* @__PURE__ */ jsx(ChevronRight, { className: "h-4 w-4" })
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "flex items-center",
+							children: [/* @__PURE__ */ jsx(Badge, {
+								variant: combinator === "AND" ? "default" : "secondary",
+								className: "mr-2 px-2 py-0.5 text-xs font-medium",
+								children: combinator === "AND" ? tr("fluidgrids.builder.conditionBuilder.combinatorAnd", "AND") : tr("fluidgrids.builder.conditionBuilder.combinatorOr", "OR")
+							}), /* @__PURE__ */ jsxs(Select, {
+								value: combinator,
+								onValueChange: handleCombinatorChange,
+								children: [/* @__PURE__ */ jsx(SelectTrigger, {
+									className: "w-[80px] h-7 text-xs",
+									children: /* @__PURE__ */ jsx(SelectValue, {})
+								}), /* @__PURE__ */ jsxs(SelectContent, { children: [/* @__PURE__ */ jsx(SelectItem, {
+									value: "AND",
+									children: tr("fluidgrids.builder.conditionBuilder.combinatorAnd", "AND")
+								}), /* @__PURE__ */ jsx(SelectItem, {
+									value: "OR",
+									children: tr("fluidgrids.builder.conditionBuilder.combinatorOr", "OR")
+								})] })]
+							})]
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "flex items-center gap-1 ml-auto",
+							children: [
+								/* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [/* @__PURE__ */ jsx(TooltipTrigger, {
+									asChild: true,
+									children: /* @__PURE__ */ jsxs(Button, {
+										onClick: handleAddRuleClick,
+										variant: "outline",
+										size: "sm",
+										className: "h-7 text-xs",
+										children: [
+											/* @__PURE__ */ jsx(Plus, { className: "mr-1 h-3 w-3" }),
+											" ",
+											tr("fluidgrids.builder.conditionBuilder.addRuleButton", "Rule")
+										]
+									})
+								}), /* @__PURE__ */ jsx(TooltipContent, { children: /* @__PURE__ */ jsx("p", { children: tr("fluidgrids.builder.conditionBuilder.addRuleTooltip", "Add a new rule") }) })] }) }),
+								/* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [/* @__PURE__ */ jsx(TooltipTrigger, {
+									asChild: true,
+									children: /* @__PURE__ */ jsxs(Button, {
+										onClick: handleAddGroupClick,
+										variant: "outline",
+										size: "sm",
+										className: "h-7 text-xs",
+										children: [
+											/* @__PURE__ */ jsx(Layers, { className: "mr-1 h-3 w-3" }),
+											" ",
+											tr("fluidgrids.builder.conditionBuilder.addGroupButton", "Group")
+										]
+									})
+								}), /* @__PURE__ */ jsx(TooltipContent, { children: /* @__PURE__ */ jsx("p", { children: tr("fluidgrids.builder.conditionBuilder.addGroupTooltip", "Add a nested group") }) })] }) }),
+								!isRoot && /* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [/* @__PURE__ */ jsx(TooltipTrigger, {
+									asChild: true,
+									children: /* @__PURE__ */ jsx(Button, {
+										variant: "ghost",
+										size: "icon",
+										onClick: handleRemove,
+										className: "h-7 w-7 text-destructive hover:text-destructive/90 hover:bg-destructive/10",
+										children: /* @__PURE__ */ jsx(Trash2, { className: "h-3 w-3" })
+									})
+								}), /* @__PURE__ */ jsx(TooltipContent, { children: /* @__PURE__ */ jsx("p", { children: tr("fluidgrids.builder.conditionBuilder.removeGroupTooltip", "Remove group") }) })] }) })
+							]
+						})
+					]
+				}), isExpanded && /* @__PURE__ */ jsxs("div", {
+					className: `space-y-3 mt-3 ${!isRoot ? "pl-4 border-l-2 border-muted/50" : ""}`,
+					children: [children.length === 0 && /* @__PURE__ */ jsxs("div", {
+						className: "flex items-center gap-2 p-3 text-sm text-muted-foreground bg-muted/20 rounded-md",
+						children: [/* @__PURE__ */ jsx(AlertCircle, { className: "h-4 w-4" }), /* @__PURE__ */ jsx("p", { children: tr("fluidgrids.builder.conditionBuilder.emptyGroupMessage", "Group is empty. Add a rule or group to get started.") })]
+					}), children.map((childNode) => /* @__PURE__ */ jsx(ConditionNodeDisplay, {
+						node: childNode,
+						path: [...path, childNode.id],
+						fieldMap,
+						parsedFields,
+						onUpdateNode,
+						onRemoveNode,
+						onAddRule,
+						onAddGroup,
+						onDuplicateNode,
+						level: level + 1
+					}, childNode.id))]
+				})]
+			})
+		});
+	}
+	return null;
+};
+const ConditionBuilder$1 = ({ outputSchema, initialCondition, onConditionChange, predefinedFields }) => {
+	const tr = useTr();
+	const [conditionTree, setConditionTree] = useState(() => initialCondition || createEmptyGroup("root"));
+	const [showDebug, setShowDebug] = useState(false);
+	const parsedFields = useMemo(() => {
+		if (predefinedFields && predefinedFields.length > 0) return predefinedFields;
+		return parseSchema(outputSchema);
+	}, [outputSchema, predefinedFields]);
+	const fieldMap = useMemo(() => {
+		return new Map(parsedFields.map((f) => [f.path, f.type]));
+	}, [parsedFields]);
+	useEffect(() => {
+		onConditionChange(conditionTree);
+	}, [conditionTree, onConditionChange]);
+	const handleUpdateNode = useCallback((nodeId, updates) => {
+		setConditionTree((prevTree) => {
+			return findAndModifyNode(prevTree, nodeId, (node) => {
+				const validUpdates = {};
+				if ("field" in updates) validUpdates.field = updates.field;
+				if ("operator" in updates) validUpdates.operator = updates.operator;
+				if ("value" in updates) validUpdates.value = updates.value;
+				if ("combinator" in updates) validUpdates.combinator = updates.combinator;
+				if ("children" in updates) validUpdates.children = updates.children;
+				return {
+					...node,
+					...validUpdates
+				};
+			});
+		});
+	}, []);
+	const handleRemoveNode = useCallback((id) => {
+		if (id === "root") {
+			console.warn("Cannot remove the root node.");
+			return;
+		}
+		setConditionTree((prevTree) => {
+			return findAndModifyNode(prevTree, id, () => null);
+		});
+	}, []);
+	const handleAddRule = useCallback((parentId) => {
+		const newRule = createEmptyRule();
+		setConditionTree((prevTree) => findAndAddNode(prevTree, parentId, newRule));
+	}, []);
+	const handleAddGroup = useCallback((parentId) => {
+		const newGroup = createEmptyGroup();
+		setConditionTree((prevTree) => findAndAddNode(prevTree, parentId, newGroup));
+	}, []);
+	const handleDuplicateNode = useCallback((id) => {
+		setConditionTree((prevTree) => {
+			let nodeToDuplicate = null;
+			findAndModifyNode(prevTree, id, (node) => {
+				nodeToDuplicate = JSON.parse(JSON.stringify(node));
+				return node;
+			});
+			if (!nodeToDuplicate) return prevTree;
+			const findParent = (node, targetId) => {
+				if (node.type === "group") for (const child of node.children) {
+					if (child.id === targetId) return node.id;
+					const result = findParent(child, targetId);
+					if (result) return result;
+				}
+				return null;
+			};
+			const parentId = findParent(prevTree, id) || "root";
+			const assignNewIds = (node) => {
+				const newId = generateId();
+				if (node.type === "rule") return {
+					...node,
+					id: newId
+				};
+				else return {
+					...node,
+					id: newId,
+					children: node.children.map((child) => assignNewIds(child))
+				};
+			};
+			const duplicateWithNewIds = assignNewIds(nodeToDuplicate);
+			return findAndAddNode(prevTree, parentId, duplicateWithNewIds);
+		});
+	}, []);
+	const handleCopyToClipboard = useCallback(() => {
+		navigator.clipboard.writeText(JSON.stringify(conditionTree, null, 2)).then(() => {
+			toast.info(tr("fluidgrids.builder.conditionBuilder.copiedToClipboardToast", "Condition tree copied to clipboard!"));
+		}).catch((err) => {
+			console.error("Failed to copy: ", err);
+		});
+	}, [conditionTree, tr]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "space-y-4 p-4 bg-background border rounded-lg shadow-sm",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center justify-between mb-4",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2",
+					children: [/* @__PURE__ */ jsx("h2", {
+						className: "text-lg font-semibold",
+						children: tr("fluidgrids.builder.conditionBuilder.title", "Condition Builder")
+					}), /* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [/* @__PURE__ */ jsx(TooltipTrigger, {
+						asChild: true,
+						children: /* @__PURE__ */ jsx(Button, {
+							variant: "ghost",
+							size: "icon",
+							className: "h-6 w-6",
+							children: /* @__PURE__ */ jsx(Info, { className: "h-4 w-4" })
+						})
+					}), /* @__PURE__ */ jsx(TooltipContent, {
+						className: "max-w-sm",
+						children: /* @__PURE__ */ jsx("p", { children: tr("fluidgrids.builder.conditionBuilder.infoTooltip", "Build complex query conditions by adding rules and groups. Rules are individual conditions, while groups combine multiple conditions with AND/OR logic.") })
+					})] }) })]
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2",
+					children: [/* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						size: "sm",
+						onClick: () => setShowDebug(!showDebug),
+						className: "text-xs",
+						children: showDebug ? tr("fluidgrids.builder.conditionBuilder.hideJsonButton", "Hide JSON") : tr("fluidgrids.builder.conditionBuilder.showJsonButton", "Show JSON")
+					}), /* @__PURE__ */ jsxs(Button, {
+						variant: "outline",
+						size: "sm",
+						onClick: handleCopyToClipboard,
+						className: "text-xs",
+						children: [
+							/* @__PURE__ */ jsx(Copy, { className: "h-3 w-3 mr-1" }),
+							" ",
+							tr("fluidgrids.builder.conditionBuilder.copyJsonButton", "Copy JSON")
+						]
+					})]
+				})]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "relative",
+				children: /* @__PURE__ */ jsx(ScrollArea, {
+					className: "max-h-[600px] pr-4",
+					children: /* @__PURE__ */ jsx(ConditionNodeDisplay, {
+						node: conditionTree,
+						path: ["root"],
+						fieldMap,
+						parsedFields,
+						onUpdateNode: handleUpdateNode,
+						onRemoveNode: handleRemoveNode,
+						onAddRule: handleAddRule,
+						onAddGroup: handleAddGroup,
+						onDuplicateNode: handleDuplicateNode,
+						level: 0
+					})
+				})
+			}),
+			showDebug && /* @__PURE__ */ jsxs("div", {
+				className: "mt-6 border-t pt-4",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "flex items-center justify-between mb-2",
+					children: [/* @__PURE__ */ jsx(Label, {
+						className: "text-sm font-medium",
+						children: tr("fluidgrids.builder.conditionBuilder.debugJsonLabel", "Condition Tree JSON:")
+					}), /* @__PURE__ */ jsxs(Button, {
+						variant: "ghost",
+						size: "sm",
+						onClick: handleCopyToClipboard,
+						className: "h-7 text-xs",
+						children: [
+							/* @__PURE__ */ jsx(Copy, { className: "h-3 w-3 mr-1" }),
+							" ",
+							tr("fluidgrids.builder.conditionBuilder.copyButton", "Copy")
+						]
+					})]
+				}), /* @__PURE__ */ jsx("div", {
+					className: "relative",
+					children: /* @__PURE__ */ jsx(ScrollArea, {
+						className: "h-[200px]",
+						children: /* @__PURE__ */ jsx("pre", {
+							className: "p-4 bg-muted rounded-md text-xs font-mono",
+							children: /* @__PURE__ */ jsx("code", { children: JSON.stringify(conditionTree, null, 2) })
+						})
+					})
+				})]
+			})
+		]
+	});
+};
+
+// src/builder/components/flow-builder/components/edges/conditionBuilder/graphql-condition-builder.tsx
+const Alert = ({ children, variant, className }) => /* @__PURE__ */ jsx("div", {
+	className: `relative w-full rounded-lg border p-4 ${variant === "destructive" ? "border-destructive/50 text-destructive bg-destructive/10" : "border-border"} ${className || ""}`,
+	children: /* @__PURE__ */ jsx("div", {
+		className: "flex gap-3",
+		children
+	})
+});
+const AlertTitle = ({ children }) => /* @__PURE__ */ jsx("h5", {
+	className: "mb-1 font-medium leading-none tracking-tight",
+	children
+});
+const AlertDescription = ({ children }) => /* @__PURE__ */ jsx("div", {
+	className: "text-sm opacity-90",
+	children
+});
+const findTypeInSchema = (types, typeName) => {
+	return types[typeName];
+};
+const mapGraphQLTypeToJSONType = (graphqlType) => {
+	return {
+		String: "string",
+		Int: "integer",
+		Float: "number",
+		Boolean: "boolean",
+		ID: "string"
+	}[graphqlType] || "string";
+};
+const extractFields = (schemaToExtract) => {
+	const extractedFields = [];
+	const processObject = (obj, path = "") => {
+		if (!obj || typeof obj !== "object") return;
+		if (obj.type) extractedFields.push({
+			path,
+			type: obj.type
+		});
+		if (obj.type === "object" && obj.properties) Object.keys(obj.properties).forEach((key) => {
+			const newPath = path ? `${path}.${key}` : key;
+			const property = obj.properties[key];
+			extractedFields.push({
+				path: newPath,
+				type: property.type
+			});
+			if (property.type === "object" && property.properties) processObject(property, newPath);
+			if (property.type === "array" && property.items) {
+				extractedFields.push({
+					path: newPath,
+					type: "array"
+				});
+				if (property.items.type === "object" && property.items.properties) Object.keys(property.items.properties).forEach((itemKey) => {
+					const itemPath = `${newPath}.${itemKey}`;
+					const itemProperty = property.items.properties[itemKey];
+					extractedFields.push({
+						path: itemPath,
+						type: itemProperty.type
+					});
+					if (itemProperty.type === "object" && itemProperty.properties) processObject(itemProperty, itemPath);
+				});
+			}
+		});
+	};
+	processObject(schemaToExtract);
+	extractedFields.sort((a, b) => a.path.localeCompare(b.path));
+	return extractedFields.filter((field, index, self) => field.path && self.findIndex((f) => f.path === field.path) === index);
+};
+const buildSchemaForOperation = (types, typeObj) => {
+	if (typeObj.name === "GmailSearchResult") return {
+		type: "object",
+		properties: {
+			emails: {
+				type: "array",
+				items: {
+					type: "object",
+					properties: {
+						metadata: {
+							type: "object",
+							properties: {
+								id: { type: "string" },
+								threadId: { type: "string" },
+								subject: { type: "string" },
+								from: { type: "string" },
+								to: { type: "string" },
+								date: { type: "string" },
+								labels: {
+									type: "array",
+									items: { type: "string" }
+								}
+							}
+						},
+						snippet: { type: "string" },
+						body: { type: "string" },
+						error: { type: "string" }
+					}
+				}
+			},
+			error: { type: "string" }
+		}
+	};
+	if (typeObj.name === "GmailBatchActionResult") return {
+		type: "object",
+		properties: {
+			succeededIds: {
+				type: "array",
+				items: { type: "string" }
+			},
+			failedItems: {
+				type: "array",
+				items: {
+					type: "object",
+					properties: {
+						messageId: { type: "string" },
+						error: { type: "string" }
+					}
+				}
+			}
+		}
+	};
+	const builtSchema = {
+		type: "object",
+		properties: {}
+	};
+	const buildNestedSchema = (nestedTypeObj) => {
+		if (!nestedTypeObj) return { type: "string" };
+		const result = { type: nestedTypeObj.kind === "scalar" ? mapGraphQLTypeToJSONType(nestedTypeObj.name) : "object" };
+		if (nestedTypeObj.kind === "type" && nestedTypeObj.fields) {
+			result.properties = {};
+			Object.keys(nestedTypeObj.fields).forEach((fieldName) => {
+				const field = nestedTypeObj.fields[fieldName];
+				const fieldType = field.type;
+				const fieldTypeObj = findTypeInSchema(types, fieldType);
+				if (!fieldTypeObj) return;
+				if (fieldTypeObj.kind === "scalar") result.properties[fieldName] = {
+					type: mapGraphQLTypeToJSONType(fieldTypeObj.name),
+					description: field.description || ""
+				};
+				else if (fieldTypeObj.kind === "type" && field.isList) result.properties[fieldName] = {
+					type: "array",
+					description: field.description || "",
+					items: buildNestedSchema(fieldTypeObj)
+				};
+				else if (fieldTypeObj.kind === "type") result.properties[fieldName] = buildNestedSchema(fieldTypeObj);
+			});
+		}
+		return result;
+	};
+	if (typeObj.kind === "type" && typeObj.fields) Object.keys(typeObj.fields).forEach((fieldName) => {
+		const field = typeObj.fields[fieldName];
+		const fieldType = field.type;
+		const fieldTypeObj = findTypeInSchema(types, fieldType);
+		if (!fieldTypeObj) return;
+		if (fieldTypeObj.kind === "scalar") builtSchema.properties[fieldName] = {
+			type: mapGraphQLTypeToJSONType(fieldTypeObj.name),
+			description: field.description || ""
+		};
+		else if (field.isList) builtSchema.properties[fieldName] = {
+			type: "array",
+			items: buildNestedSchema(fieldTypeObj)
+		};
+		else if (fieldTypeObj.kind === "type") builtSchema.properties[fieldName] = buildNestedSchema(fieldTypeObj);
+	});
+	return builtSchema;
+};
+const GraphQLConditionBuilder = ({ introspectionData, operationName, initialCondition, onConditionChange }) => {
+	const tr = useTr();
+	const { schema, fields, error } = useMemo(() => {
+		try {
+			if (!introspectionData || !operationName) return {
+				schema: null,
+				fields: [],
+				error: null
+			};
+			const queryType = introspectionData.queryType;
+			const mutationType = introspectionData.mutationType;
+			const queryTypeObj = introspectionData.types[queryType];
+			const mutationTypeObj = mutationType ? introspectionData.types[mutationType] : void 0;
+			if (queryTypeObj && queryTypeObj.fields && queryTypeObj.fields[operationName]) {
+				const returnType = queryTypeObj.fields[operationName].type;
+				const returnTypeObj = findTypeInSchema(introspectionData.types, returnType);
+				if (!returnTypeObj) return {
+					schema: null,
+					fields: [],
+					error: `Return type "${returnType}" not found in schema`
+				};
+				const builtSchema = buildSchemaForOperation(introspectionData.types, returnTypeObj);
+				return {
+					schema: builtSchema,
+					fields: extractFields(builtSchema),
+					error: null
+				};
+			}
+			if (mutationTypeObj && mutationTypeObj.fields && mutationTypeObj.fields[operationName]) {
+				const returnType = mutationTypeObj.fields[operationName].type;
+				const returnTypeObj = findTypeInSchema(introspectionData.types, returnType);
+				if (!returnTypeObj) return {
+					schema: null,
+					fields: [],
+					error: `Return type "${returnType}" not found in schema`
+				};
+				const builtSchema = buildSchemaForOperation(introspectionData.types, returnTypeObj);
+				return {
+					schema: builtSchema,
+					fields: extractFields(builtSchema),
+					error: null
+				};
+			}
+			return {
+				schema: null,
+				fields: [],
+				error: `Operation "${operationName}" not found in schema`
+			};
+		} catch (err) {
+			console.error("Error building schema:", err);
+			return {
+				schema: null,
+				fields: [],
+				error: "Failed to build schema from introspection data"
+			};
+		}
+	}, [introspectionData, operationName]);
+	useEffect(() => {
+		if (schema) {}
+	}, [schema, fields]);
+	if (error) return /* @__PURE__ */ jsxs(Alert, {
+		variant: "destructive",
+		children: [
+			/* @__PURE__ */ jsx(AlertCircle, { className: "h-4 w-4" }),
+			/* @__PURE__ */ jsx(AlertTitle, { children: tr("fluidgrids.builder.graphqlConditionBuilder.errorTitle", "Error") }),
+			/* @__PURE__ */ jsx(AlertDescription, { children: error })
+		]
+	});
+	if (!schema) return /* @__PURE__ */ jsx("div", { children: tr("fluidgrids.builder.graphqlConditionBuilder.loadingSchema", "Loading schema...") });
+	return /* @__PURE__ */ jsx(ConditionBuilder$1, {
+		outputSchema: schema,
+		initialCondition,
+		onConditionChange,
+		predefinedFields: fields
+	});
+};
+
+// src/builder/components/flow-builder/components/edges/conditionBuilder/custom-condition-tree-converter.ts
+function buildConditionString(conditionJson) {
+	const getFallback = (operator, isLast) => {
+		if (!isLast) return "{}";
+		if (operator === "contains") return `''`;
+		return "0";
+	};
+	const parseField = (field, operator) => {
+		const parts = field.split(".");
+		if (parts[0] === "emails" && parts.length > 1) {
+			const arrayPath = parts[0];
+			const remainingPath = parts.slice(1).join(".");
+			if (operator === "contains" || operator === "==") return `output.${arrayPath}.some(item => item.${remainingPath})`;
+			else if (operator === "!=" || operator === "isNotNull") return `output.${arrayPath}.some(item => item.${remainingPath})`;
+			else return `output.${arrayPath}[0]?.${remainingPath}`;
+		}
+		return `output${parts.map((key, i) => {
+			const isLast = i === parts.length - 1;
+			return `.get('${key}', ${getFallback(operator, isLast)})`;
+		}).join("")}`;
+	};
+	const parseRule = (rule) => {
+		const { field, operator, value } = rule;
+		const parts = field.split(".");
+		if (parts[0] === "emails" && parts.length > 1) {
+			const remainingPath = parts.slice(1).join(".");
+			const stringValue = typeof value === "string" ? `'${value}'` : value;
+			if (operator === "contains") return `output.emails.some(item => item.${remainingPath}?.includes(${stringValue}))`;
+			else if (operator === "==") return `output.emails.some(item => item.${remainingPath} === ${stringValue})`;
+			else if (operator === "!=") return `output.emails.some(item => item.${remainingPath} !== ${stringValue})`;
+			else if (operator === ">") return `output.emails.some(item => item.${remainingPath} > ${stringValue})`;
+			else if (operator === ">=") return `output.emails.some(item => item.${remainingPath} >= ${stringValue})`;
+			else if (operator === "<") return `output.emails.some(item => item.${remainingPath} < ${stringValue})`;
+			else if (operator === "<=") return `output.emails.some(item => item.${remainingPath} <= ${stringValue})`;
+			else if (operator === "isNull") return `output.emails.some(item => item.${remainingPath} === null || item.${remainingPath} === undefined)`;
+			else if (operator === "isNotNull") return `output.emails.some(item => item.${remainingPath} !== null && item.${remainingPath} !== undefined)`;
+			else if (operator === "hasProperty") return `output.emails.some(item => '${value}' in item.${remainingPath})`;
+		}
+		const fieldStr = parseField(field, operator);
+		const stringValue = typeof value === "string" ? `'${value}'` : value;
+		const opMap = {
+			contains: "includes",
+			"==": "==",
+			"!=": "!=",
+			">": ">",
+			"<": "<",
+			">=": ">=",
+			"<=": "<=",
+			hasProperty: "hasProperty"
+		};
+		if (operator === "contains") return `${fieldStr}.includes(${stringValue})`;
+		else if (operator === "hasProperty") return `'${value}' in output${field.split(".").map((part) => `.get('${part}', {})`).join("")}`;
+		else return `${fieldStr} ${opMap[operator] ?? operator} ${stringValue}`;
+	};
+	const parseGroup = (group) => {
+		const combinator = group.combinator.toLowerCase();
+		return group.children.map((child) => {
+			if (child.type === "rule") return parseRule(child);
+			else return `(${parseGroup(child)})`;
+		}).join(` ${combinator} `);
+	};
+	return parseGroup(conditionJson);
+}
+
+// src/builder/components/flow-builder/components/edges/conditionBuilder/index.tsx
+function convertToIntrospectionData(schema) {
+	if (!schema.queryType) return null;
+	return {
+		queryType: schema.queryType,
+		mutationType: schema.mutationType ?? void 0,
+		types: Object.fromEntries(Object.entries(schema.types).map(([key, value]) => [key, {
+			name: value.name,
+			kind: value.kind,
+			fields: value.fields ? Object.fromEntries(Object.entries(value.fields).map(([fieldKey, fieldValue]) => [fieldKey, {
+				type: fieldValue.type,
+				isList: fieldValue.isList,
+				isNonNull: fieldValue.isNonNull
+			}])) : void 0
+		}]))
+	};
+}
+function ConditionBuilder({ sourceNode, sourceOperation, edgeId, schema }) {
+	const tr = useTr();
+	const { setEdges } = useReactFlow();
+	const [conditionTree, setConditionTree] = useState(null);
+	const [conditionString, setConditionString] = useState("");
+	const selectedOperation = sourceOperation || sourceNode?.data?.operation_name || "";
+	const rawSchema = schema || sourceNode?.data?.schema || sourceNode?.data?.nodeData?.schema || null;
+	const introspectionData = useMemo(() => {
+		if (!rawSchema) return null;
+		return convertToIntrospectionData(rawSchema);
+	}, [rawSchema]);
+	const handleConditionChange = (newTree) => {
+		setConditionTree(newTree);
+		try {
+			const condString = buildConditionString(newTree);
+			setConditionString(condString);
+		} catch (error) {
+			console.error("Error building condition string:", error);
+		}
+	};
+	useEffect(() => {
+		setEdges((edges) => {
+			return edges.map((edge) => {
+				if (edge.id === edgeId) return {
+					...edge,
+					condition: conditionString
+				};
+				else return edge;
+			});
+		});
+	}, [
+		conditionString,
+		edgeId,
+		setEdges
+	]);
+	if (!introspectionData) return /* @__PURE__ */ jsxs("div", {
+		className: "flex items-center justify-center min-h-[200px] text-muted-foreground",
+		children: [/* @__PURE__ */ jsx(AlertCircle, { className: "h-6 w-6 mr-2" }), /* @__PURE__ */ jsx("span", { children: tr("fluidgrids.builder.conditionBuilder.noSchema", "No schema available for this node. Configure the node schema first.") })]
+	});
+	return /* @__PURE__ */ jsx("div", {
+		className: "container mx-auto py-8",
+		children: introspectionData && selectedOperation && /* @__PURE__ */ jsxs(Tabs, {
+			defaultValue: "builder",
+			className: "w-full",
+			children: [
+				/* @__PURE__ */ jsxs(TabsList, {
+					className: "mb-4",
+					children: [/* @__PURE__ */ jsx(TabsTrigger, {
+						value: "builder",
+						children: tr("fluidgrids.builder.conditionBuilder.tabBuilder", "Condition Builder")
+					}), /* @__PURE__ */ jsx(TabsTrigger, {
+						value: "output",
+						children: tr("fluidgrids.builder.conditionBuilder.tabOutput", "Generated Output")
+					})]
+				}),
+				/* @__PURE__ */ jsx(TabsContent, {
+					value: "builder",
+					children: /* @__PURE__ */ jsx(GraphQLConditionBuilder, {
+						introspectionData,
+						operationName: selectedOperation,
+						initialCondition: conditionTree || {
+							id: "root",
+							type: "group",
+							combinator: "AND",
+							children: []
+						},
+						onConditionChange: handleConditionChange
+					})
+				}),
+				/* @__PURE__ */ jsx(TabsContent, {
+					value: "output",
+					children: /* @__PURE__ */ jsxs(Card, { children: [/* @__PURE__ */ jsxs(CardHeader, { children: [/* @__PURE__ */ jsx(CardTitle, { children: tr("fluidgrids.builder.conditionBuilder.generatedConditionTitle", "Generated Condition") }), /* @__PURE__ */ jsxs(CardDescription, { children: [
+						tr("fluidgrids.builder.conditionBuilder.generatedConditionDescriptionStart", "The condition string that will be used to filter"),
+						" ",
+						selectedOperation,
+						" ",
+						tr("fluidgrids.builder.conditionBuilder.generatedConditionDescriptionEnd", "results")
+					] })] }), /* @__PURE__ */ jsx(CardContent, { children: /* @__PURE__ */ jsx(ScrollArea, {
+						className: "h-[300px] w-full rounded-md border p-4",
+						children: /* @__PURE__ */ jsx("pre", {
+							className: "font-mono text-sm",
+							children: conditionString || tr("fluidgrids.builder.conditionBuilder.noConditionYet", "No condition generated yet")
+						})
+					}) })] })
+				})
+			]
+		})
+	});
+}
+
+export { ConditionBuilder as default };