@flowuent-org/diagramming-core 1.1.0 → 1.1.2

package/dist/out-tsc/packages/diagrams/src/lib/utils/flow-to-js.js

@@ -1,1132 +0,0 @@
-export const flowToCode = (json) => {
-    const externalFunctions = [];
-    // Clone the JSON without processed flag
-    const clonedJson = {
-        nodes: json.nodes.map((node) => (Object.assign({}, node))),
-        edges: json.edges.map((edge) => (Object.assign({}, edge))),
-    };
-    // Track processed nodes to prevent duplicates
-    const processedNodes = new Set();
-    // --- Move processNode and createBlockFlow above jsonToJavaScript for scope ---
-    const processNode = (n, visited) => {
-        var _a, _b, _c, _d, _e;
-        if (!n || visited.has(n.id) || processedNodes.has(n.id))
-            return;
-        visited.add(n.id);
-        processedNodes.add(n.id);
-        // Determine the node type based on data structure
-        let nodeType = ((_a = n.data.formData) === null || _a === void 0 ? void 0 : _a.type) || n.data.type || 'emptyNode';
-        // Check if this is a function call node based on data structure
-        let isFunctionCall = false;
-        if (n.data.formData &&
-            ('functionName' in n.data.formData || 'args' in n.data.formData)) {
-            isFunctionCall = true;
-        }
-        const res = {
-            id: n.id,
-            type: nodeType,
-            title: n.data.title,
-            isFunctionCall,
-        };
-        // Debug type assignment for function nodes
-        if (((_b = n.data.formData) === null || _b === void 0 ? void 0 : _b.type) === 'function') {
-            console.log('Function node type assignment:', {
-                id: n.id,
-                title: n.data.title,
-                formDataType: (_c = n.data.formData) === null || _c === void 0 ? void 0 : _c.type,
-                dataType: n.data.type,
-                assignedType: res.type,
-            });
-        }
-        // Add compatible properties from formData based on node type
-        if (n.data.formData) {
-            const formData = n.data.formData;
-            // Add properties that are directly compatible with MiddleSchema
-            if ('name' in formData)
-                res.name = formData.name;
-            if ('parameters' in formData) {
-                // Handle both old string[] format and new FunctionParameter[] format
-                const params = formData.parameters;
-                if (Array.isArray(params)) {
-                    if (params.length > 0 && typeof params[0] === 'string') {
-                        // Old format: string[]
-                        res.parameters = params;
-                    }
-                    else if (params.length > 0 &&
-                        typeof params[0] === 'object' &&
-                        'name' in params[0]) {
-                        // New format: FunctionParameter[]
-                        res.parameters = params;
-                    }
-                }
-            }
-            if ('variable' in formData)
-                res.variable = formData.variable;
-            if ('value' in formData)
-                res.value = formData.value;
-            if ('condition' in formData)
-                res.condition = formData.condition;
-            if ('bindings' in formData)
-                res.bindings = formData.bindings;
-            if ('mode' in formData)
-                res.mode = formData.mode;
-            if ('objectDefinition' in formData)
-                res.objectDefinition = formData.objectDefinition;
-            if ('customCode' in formData) {
-                res.customCode = formData.customCode;
-                if (formData.type === 'function') {
-                    console.log('Extracted custom code from function formData:', {
-                        functionName: res.name,
-                        customCode: res.customCode,
-                        customCodeLength: (_d = res.customCode) === null || _d === void 0 ? void 0 : _d.length,
-                    });
-                }
-            }
-            if ('init' in formData) {
-                if (typeof formData.init === 'string') {
-                    res.init = formData.init;
-                }
-                else if (typeof formData.init === 'object' &&
-                    'operation' in formData.init) {
-                    // Convert operation expression to string representation
-                    const op = formData.init;
-                    // Handle special operators that need different formatting
-                    switch (op.operation) {
-                        case '=':
-                            // Assignment operator - no parentheses needed
-                            res.init =
-                                `${op.operands[0] || ''} = ${op.operands[1] || ''}`.trim();
-                            break;
-                        case '==':
-                        case '!=':
-                            // Equality operators - use parentheses for clarity
-                            res.init =
-                                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
-                            break;
-                        default:
-                            // All other operators - use parentheses
-                            res.init =
-                                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
-                    }
-                }
-            }
-            if ('update' in formData) {
-                if (typeof formData.update === 'string') {
-                    res.update = formData.update;
-                }
-                else if (typeof formData.update === 'object' &&
-                    'operation' in formData.update) {
-                    // Convert operation expression to string representation
-                    const op = formData.update;
-                    // Handle special operators that need different formatting
-                    switch (op.operation) {
-                        case '=':
-                            // Assignment operator - no parentheses needed
-                            res.update =
-                                `${op.operands[0] || ''} = ${op.operands[1] || ''}`.trim();
-                            break;
-                        case '==':
-                        case '!=':
-                            // Equality operators - use parentheses for clarity
-                            res.update =
-                                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
-                            break;
-                        default:
-                            // All other operators - use parentheses
-                            res.update =
-                                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
-                    }
-                }
-            }
-            if ('switchValue' in formData) {
-                if (typeof formData.switchValue === 'string') {
-                    res.switchValue = formData.switchValue;
-                }
-                else if (typeof formData.switchValue === 'object' &&
-                    'operation' in formData.switchValue) {
-                    // Convert operation expression to string representation
-                    const op = formData.switchValue;
-                    // Handle special operators that need different formatting
-                    switch (op.operation) {
-                        case '=':
-                            // Assignment operator - no parentheses needed
-                            res.switchValue =
-                                `${op.operands[0] || ''} = ${op.operands[1] || ''}`.trim();
-                            break;
-                        case '==':
-                        case '!=':
-                            // Equality operators - use parentheses for clarity
-                            res.switchValue =
-                                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
-                            break;
-                        default:
-                            // All other operators - use parentheses
-                            res.switchValue =
-                                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
-                    }
-                }
-            }
-            if ('errorVar' in formData)
-                res.errorVar = formData.errorVar;
-            if ('dataType' in formData)
-                res.dataType = formData.dataType;
-            if ('valueDataType' in formData)
-                res.valueDataType = formData.valueDataType;
-            if ('conditionDataType' in formData)
-                res.conditionDataType = formData.conditionDataType;
-            if ('initDataType' in formData)
-                res.initDataType = formData.initDataType;
-            if ('updateDataType' in formData)
-                res.updateDataType = formData.updateDataType;
-            // Handle function call specific properties
-            if ('functionName' in formData)
-                res.functionName = formData.functionName;
-            if ('args' in formData) {
-                res.args = formData.args.map((arg) => ({
-                    name: arg.name,
-                    value: typeof arg.value === 'string'
-                        ? arg.value
-                        : (() => {
-                            const op = arg.value;
-                            // Handle special operators that need different formatting
-                            switch (op.operation) {
-                                case '=':
-                                    // Assignment operator - no parentheses needed
-                                    return `${op.operands[0] || ''} = ${op.operands[1] || ''}`.trim();
-                                case '==':
-                                case '!=':
-                                    // Equality operators - use parentheses for clarity
-                                    return `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
-                                default:
-                                    // All other operators - use parentheses
-                                    return `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
-                            }
-                        })(),
-                    dataType: arg.dataType,
-                }));
-            }
-            if ('returnValueName' in formData && formData.returnValueName) {
-                if (typeof formData.returnValueName === 'string') {
-                    res.returnValueName = formData.returnValueName;
-                }
-                else if (typeof formData.returnValueName === 'object' &&
-                    'operation' in formData.returnValueName) {
-                    // Convert operation expression to string representation
-                    const op = formData.returnValueName;
-                    // Handle special operators that need different formatting
-                    switch (op.operation) {
-                        case '=':
-                            // Assignment operator - no parentheses needed
-                            res.returnValueName =
-                                `${op.operands[0] || ''} = ${op.operands[1] || ''}`.trim();
-                            break;
-                        case '==':
-                        case '!=':
-                            // Equality operators - use parentheses for clarity
-                            res.returnValueName =
-                                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
-                            break;
-                        default:
-                            // All other operators - use parentheses
-                            res.returnValueName =
-                                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
-                    }
-                }
-            }
-            if ('returnValueDataType' in formData)
-                res.returnValueDataType = formData.returnValueDataType;
-            // Handle API node specific properties
-            if ('method' in formData)
-                res.method = formData.method;
-            if ('url' in formData)
-                res.url = formData.url;
-            if ('headers' in formData)
-                res.headers = formData.headers;
-            if ('queryParams' in formData)
-                res.queryParams = formData.queryParams;
-            if ('body' in formData)
-                res.requestBody = formData.body;
-            if ('bodyType' in formData)
-                res.bodyType = formData.bodyType;
-            if ('responseVariable' in formData)
-                res.responseVariable = formData.responseVariable;
-            if ('responseDataType' in formData)
-                res.responseDataType = formData.responseDataType;
-            // Handle GraphQL node specific properties
-            if ('mode' in formData)
-                res.graphqlMode = formData.mode;
-            if ('operationType' in formData)
-                res.operationType = formData.operationType;
-            if ('operationName' in formData)
-                res.operationName = formData.operationName;
-            if ('rootField' in formData)
-                res.rootField = formData.rootField;
-            if ('arguments' in formData)
-                res.arguments = formData.arguments;
-            if ('fields' in formData)
-                res.fields = formData.fields;
-            if ('variables' in formData)
-                res.variables = formData.variables;
-            if ('customQuery' in formData)
-                res.customQuery = formData.customQuery;
-        }
-        // Handle conditions from node data (RuleGroup format)
-        if (n.data.conditions) {
-            res.conditions = n.data.conditions;
-        }
-        // Handle branch nodes (true/false cases)
-        const isBranchRoot = n.data.branchRoot === n.id;
-        if (isBranchRoot) {
-            const trueCase = clonedJson.nodes.find((node) => n.data.trueCase === node.id);
-            if (trueCase) {
-                res.true = createBlockFlow(trueCase, visited);
-            }
-            const falseCase = clonedJson.nodes.find((node) => n.data.falseCase === node.id);
-            if (falseCase) {
-                res.false = createBlockFlow(falseCase, visited);
-            }
-        }
-        // Handle try/catch nodes
-        if (n.data.type === 'try') {
-            // Only process catch block via edges if we don't already have child nodes
-            // Child nodes are processed above in the general child node handling
-            if (!res.body || res.body.length === 0) {
-                // Outgoing edges: one to body, one to catch
-                const outgoingEdges = clonedJson.edges.filter((edge) => edge.source === n.id);
-                // Body edge: not to a catch node
-                const bodyEdge = outgoingEdges.find((edge) => {
-                    const targetNode = clonedJson.nodes.find((node) => node.id === edge.target);
-                    return targetNode && targetNode.data.type !== 'catch';
-                });
-                if (bodyEdge) {
-                    const bodyNode = clonedJson.nodes.find((node) => node.id === bodyEdge.target);
-                    if (bodyNode) {
-                        res.body = createBlockFlow(bodyNode, visited);
-                    }
-                }
-            }
-            // Catch edge: to a catch node
-            const catchEdge = clonedJson.edges.find((edge) => {
-                return (edge.source === n.id &&
-                    clonedJson.nodes.find((node) => node.id === edge.target && node.data.type === 'catch'));
-            });
-            if (catchEdge) {
-                const catchNode = clonedJson.nodes.find((node) => node.id === catchEdge.target);
-                if (catchNode) {
-                    // Create a new visited set for the catch node to avoid conflicts
-                    const catchVisited = new Set(visited);
-                    // Remove the catch node from visited set if it's already there
-                    catchVisited.delete(catchNode.id);
-                    res.catchBlock = processNode(catchNode, catchVisited);
-                }
-            }
-        }
-        // Handle switch/case nodes
-        if (n.data.type === 'switch' || ((_e = n.data.formData) === null || _e === void 0 ? void 0 : _e.type) === 'switch') {
-            // All outgoing edges are to case or default nodes
-            const caseEdges = clonedJson.edges.filter((edge) => edge.source === n.id);
-            // Create case node schemas directly without calling processNode to avoid conflicts
-            res.body = caseEdges
-                .map((edge) => {
-                const caseNode = clonedJson.nodes.find((node) => edge.target === node.id);
-                if (caseNode) {
-                    // Create case node schema directly
-                    const caseSchema = {
-                        id: caseNode.id,
-                        type: 'case',
-                        title: caseNode.data.title || '',
-                    };
-                    const caseChildNodes = clonedJson.nodes.filter((childNode) => {
-                        return childNode.parentId === caseNode.id;
-                    });
-                    if (caseChildNodes.length > 0) {
-                        // Process child nodes as body of the case
-                        caseSchema.body = caseChildNodes
-                            .map((childNode) => processNode(childNode, visited))
-                            .filter(Boolean);
-                    }
-                    return caseSchema;
-                }
-                return undefined;
-            })
-                .filter(Boolean);
-        }
-        // Handle nodes that can have child nodes (nested scope)
-        // These are nodes that can contain other nodes within their scope
-        if (['forLoop', 'loop', 'catch', 'try'].includes(n.data.type || '')) {
-            // Find child nodes (nodes that have this node as parent)
-            const childNodes = clonedJson.nodes.filter((node) => {
-                return node.parentId === n.id;
-            });
-            if (childNodes.length > 0) {
-                // Process child nodes as body of this node
-                res.body = childNodes
-                    .map((childNode) => processNode(childNode, visited))
-                    .filter(Boolean);
-            }
-        }
-        return res;
-    };
-    const createBlockFlow = (firstNode, visited, stopAtFunctions = false) => {
-        var _a;
-        const flow = [];
-        let currentNode = firstNode;
-        while (currentNode) {
-            // Skip catch nodes in linear flow - they should only be processed by try nodes
-            if (currentNode.data.type === 'catch') {
-                break;
-            }
-            // Stop if we encounter another function node (when stopAtFunctions is true)
-            if (stopAtFunctions && ((_a = currentNode.data.formData) === null || _a === void 0 ? void 0 : _a.type) === 'function') {
-                break;
-            }
-            // Skip if already processed
-            if (processedNodes.has(currentNode.id)) {
-                break;
-            }
-            const nodeResult = processNode(currentNode, visited);
-            if (!nodeResult)
-                break;
-            flow.push(nodeResult);
-            // Find next node in the flow (edge-connected, same level)
-            let edgesNext = clonedJson.edges.filter((edge) => edge.source === (currentNode === null || currentNode === void 0 ? void 0 : currentNode.id));
-            // Handle branch final node
-            const isBranchRoot = currentNode.data.branchRoot === currentNode.id;
-            let finalNodeId = isBranchRoot && currentNode.data.finalNodeId
-                ? clonedJson.nodes.find((n) => (currentNode === null || currentNode === void 0 ? void 0 : currentNode.data.finalNodeId) === n.id)
-                : undefined;
-            if (finalNodeId) {
-                currentNode = finalNodeId;
-                continue;
-            }
-            // Follow edge to next node (same level)
-            if (edgesNext.length === 1) {
-                const edge = edgesNext[0];
-                const nextNode = clonedJson.nodes.find((node) => edge.target === node.id);
-                if (nextNode) {
-                    const previousEdgesOfNextNode = clonedJson.edges.filter((edge) => edge.target === (nextNode === null || nextNode === void 0 ? void 0 : nextNode.id));
-                    if (previousEdgesOfNextNode.length === 1) {
-                        currentNode = nextNode;
-                        continue;
-                    }
-                }
-            }
-            break;
-        }
-        return flow;
-    };
-    // Helper function to find nodes that belong to a specific function
-    const findNodesBelongingToFunction = (functionNode, allNodes, allEdges, excludedFunctionIds) => {
-        // Find the first node that's connected to this function
-        const firstConnectedNode = allEdges
-            .filter((edge) => edge.source === functionNode.id)
-            .map((edge) => allNodes.find((n) => n.id === edge.target))
-            .find((node) => { var _a; return node && ((_a = node.data.formData) === null || _a === void 0 ? void 0 : _a.type) !== 'function'; });
-        if (!firstConnectedNode) {
-            return [];
-        }
-        // Use createBlockFlow to get the proper flow of nodes
-        // This will handle all the control structures and nested flows correctly
-        const visited = new Set();
-        visited.add(functionNode.id); // Mark function node as visited to avoid processing it
-        const result = createBlockFlow(firstConnectedNode, visited, true); // Stop at functions to prevent overlap
-        return result;
-    };
-    function jsonToJavaScript(json) {
-        function parseNode(node) {
-            switch (node.type) {
-                case 'emptyNode':
-                    return '';
-                case 'function':
-                    return parseFunction(node);
-                case 'call':
-                    return parseCall(node);
-                case 'branch':
-                    return parseBranch(node);
-                case 'let':
-                    return parseLet(node);
-                case 'loop':
-                    return parseLoop(node);
-                case 'forLoop':
-                    return parseForLoop(node);
-                case 'set':
-                    return parseSet(node);
-                case 'return':
-                    return parseReturn(node);
-                case 'try':
-                    return parseTry(node);
-                case 'catch':
-                    return parseCatch(node);
-                case 'switch':
-                    return parseSwitch(node);
-                case 'case':
-                    return parseCaseNode(node);
-                case 'api':
-                    return parseApi(node);
-                case 'graphql':
-                    return parseGraphQL(node);
-                default:
-                    // Check if this node has function call properties even if type is not 'call'
-                    if (node.isFunctionCall || (node.functionName && node.args)) {
-                        return parseCall(node);
-                    }
-                    throw new Error(`Unknown node type: ${node.type}`);
-            }
-        }
-        const parseCall = (node) => {
-            // Extract function call data from the node
-            const functionName = node.functionName || 'unknownFunction';
-            const args = node.args || [];
-            const returnValueName = node.returnValueName || '';
-            // Extract arguments' values, providing a default empty string if value is undefined
-            const argValues = args.map((arg) => {
-                // If the value is empty, use the name as a variable reference
-                if (arg.value && arg.value.trim() !== '') {
-                    // Format the value based on data type
-                    const value = arg.value.trim();
-                    const dataType = arg.dataType || 'String';
-                    switch (dataType) {
-                        case 'String':
-                        case 'STRING':
-                        case 'CHAR':
-                        case 'TEXT':
-                            // For string types, always wrap in quotes unless it's already quoted
-                            if ((value.startsWith('"') && value.endsWith('"')) ||
-                                (value.startsWith("'") && value.endsWith("'"))) {
-                                return value; // Already quoted
-                            }
-                            return `'${value}'`;
-                        case 'Number':
-                        case 'INT':
-                        case 'FLOAT':
-                            // For number types, ensure it's not quoted
-                            return value;
-                        case 'Boolean':
-                        case 'BOOLEAN':
-                            // For boolean types, ensure it's not quoted
-                            return value;
-                        case 'Object':
-                            // For object type, try to parse as JSON or wrap in quotes if it's a string
-                            try {
-                                JSON.parse(value);
-                                return value; // Valid JSON
-                            }
-                            catch (_a) {
-                                return `'${value}'`; // Not valid JSON, treat as string
-                            }
-                        case 'Array':
-                            // For array type, try to parse as JSON or wrap in quotes if it's a string
-                            try {
-                                JSON.parse(value);
-                                return value; // Valid JSON
-                            }
-                            catch (_b) {
-                                return `'${value}'`; // Not valid JSON, treat as string
-                            }
-                        case 'Date':
-                        case 'DATE':
-                        case 'TIME':
-                        case 'DATETIME':
-                            // For date types, wrap in quotes to preserve as string
-                            if ((value.startsWith('"') && value.endsWith('"')) ||
-                                (value.startsWith("'") && value.endsWith("'"))) {
-                                return value; // Already quoted
-                            }
-                            return `'${value}'`;
-                        case 'Map':
-                        case 'Set':
-                            // For Map and Set types, try to parse as JSON or wrap in quotes if it's a string
-                            try {
-                                JSON.parse(value);
-                                return value; // Valid JSON
-                            }
-                            catch (_c) {
-                                return `'${value}'`; // Not valid JSON, treat as string
-                            }
-                        default:
-                            // For other types, default to string behavior
-                            if ((value.startsWith('"') && value.endsWith('"')) ||
-                                (value.startsWith("'") && value.endsWith("'"))) {
-                                return value; // Already quoted
-                            }
-                            return `'${value}'`;
-                    }
-                }
-                return arg.name;
-            });
-            // Format the function call
-            const functionCall = `${functionName}(${argValues.join(', ')})`;
-            // Return formatted code
-            return returnValueName
-                ? `const ${returnValueName} = ${functionCall};`
-                : `${functionCall};`;
-        };
-        function parseFunction(node) {
-            var _a, _b, _c;
-            console.log('Parsing function node:', {
-                name: node.name,
-                hasCustomCode: !!node.customCode,
-                customCodeLength: (_a = node.customCode) === null || _a === void 0 ? void 0 : _a.length,
-                customCode: node.customCode,
-            });
-            const params = (_b = node.parameters) === null || _b === void 0 ? void 0 : _b.map((param) => {
-                if (typeof param === 'string') {
-                    return param;
-                }
-                else if (typeof param === 'object' &&
-                    'name' in param &&
-                    'type' in param) {
-                    const { name, type } = param;
-                    return `${name}: ${type}`;
-                }
-                return '';
-            }).join(', ');
-            if (node.customCode) {
-                console.log('Using custom code for function:', node.name);
-                // Wrap the custom code in the function declaration
-                return `function ${node.name}(${params}) {\n  ${node.customCode}\n}`;
-            }
-            console.log('Generating function from body for:', node.name);
-            const body = ((_c = node.body) === null || _c === void 0 ? void 0 : _c.filter((n) => n !== undefined).map(parseNode).join('\n  ')) || '';
-            return `function ${node.name}(${params}) {\n  ${body}\n}`;
-        }
-        // Helper function to parse RuleGroup to JavaScript expression
-        function parseRuleGroup(ruleGroup) {
-            if (ruleGroup.rules.length === 0)
-                return 'true';
-            const ruleExpressions = ruleGroup.rules.map((rule) => {
-                if ('combinator' in rule) {
-                    // Nested RuleGroup
-                    return `(${parseRuleGroup(rule)})`;
-                }
-                else {
-                    // Single Rule
-                    return parseRule(rule);
-                }
-            });
-            const operator = ruleGroup.combinator === 'and' ? '&&' : '||';
-            return ruleExpressions.join(` ${operator} `);
-        }
-        // Helper function to parse a single Rule to JavaScript expression
-        function parseRule(rule) {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
-            // Debug logging
-            console.log('Parsing rule:', rule);
-            // Handle field
-            let field;
-            if ((_a = rule.field) === null || _a === void 0 ? void 0 : _a.rawValue) {
-                // Plain text input
-                field = rule.field.rawValue;
-            }
-            else if (((_b = rule.field) === null || _b === void 0 ? void 0 : _b.label) && ((_c = rule.field) === null || _c === void 0 ? void 0 : _c.type)) {
-                // Structured input with type and label
-                field = `{{${rule.field.type}.${rule.field.label}}}`;
-            }
-            else {
-                // Fallback
-                field = ((_d = rule.field) === null || _d === void 0 ? void 0 : _d.label) || '';
-            }
-            // Handle value
-            let value;
-            if ((_e = rule.value) === null || _e === void 0 ? void 0 : _e.rawValue) {
-                // Plain text input
-                value = rule.value.rawValue;
-            }
-            else if (((_f = rule.value) === null || _f === void 0 ? void 0 : _f.label) && ((_g = rule.value) === null || _g === void 0 ? void 0 : _g.type)) {
-                // Structured input with type and label
-                value = `{{${rule.value.type}.${rule.value.label}}}`;
-            }
-            else {
-                // Fallback
-                value = ((_h = rule.value) === null || _h === void 0 ? void 0 : _h.label) || '';
-            }
-            console.log('Parsed field:', field, 'value:', value);
-            switch (rule.operator) {
-                case '=':
-                    return `${field} === ${value}`;
-                case '!=':
-                    return `${field} !== ${value}`;
-                case '>':
-                    return `${field} > ${value}`;
-                case '<':
-                    return `${field} < ${value}`;
-                case '>=':
-                    return `${field} >= ${value}`;
-                case '<=':
-                    return `${field} <= ${value}`;
-                default:
-                    return `${field} === ${value}`;
-            }
-        }
-        function parseBranch(node) {
-            var _a;
-            let condition;
-            // Check if we have multiple conditions (RuleGroup) or single condition
-            if (node.conditions && node.conditions.rules.length > 0) {
-                condition = parseRuleGroup(node.conditions);
-            }
-            else {
-                condition = parseExpression(node.condition || '');
-            }
-            const trueBranch = ((_a = node.true) === null || _a === void 0 ? void 0 : _a.filter((n) => n !== undefined).map(parseNode).join('\n  ')) || '';
-            const falseBranch = node.false
-                ? node.false
-                    .filter((n) => n !== undefined)
-                    .map(parseNode)
-                    .join('\n  ')
-                : '';
-            return `if (${condition}) {\n  ${trueBranch}\n}${falseBranch ? ` else {\n  ${falseBranch}\n}` : ''}`;
-        }
-        function parseLet(node) {
-            var _a;
-            // Handle different modes
-            if (node.mode === 'code' && node.customCode) {
-                return node.customCode;
-            }
-            if (node.mode === 'object' && node.objectDefinition) {
-                return parseObjectDefinition(node.objectDefinition);
-            }
-            // Default to simple bindings mode
-            const bindings = (_a = node.bindings) === null || _a === void 0 ? void 0 : _a.map(([name, value]) => `let ${name} = ${parseExpression(value || '')};`).join('\n');
-            return bindings || '';
-        }
-        // Helper function to parse object definition
-        function parseObjectDefinition(objectDef) {
-            if (!objectDef.variableName ||
-                !objectDef.properties ||
-                objectDef.properties.length === 0) {
-                return '';
-            }
-            const properties = objectDef.properties
-                .map((prop) => {
-                const key = prop.key;
-                const value = parseExpression(prop.value || '');
-                return `  ${key}: ${value}`;
-            })
-                .join(',\n');
-            return `let ${objectDef.variableName} = {\n${properties}\n};`;
-        }
-        function parseLoop(node) {
-            var _a;
-            let condition;
-            // Check if we have multiple conditions (RuleGroup) or single condition
-            if (node.conditions && node.conditions.rules.length > 0) {
-                condition = parseRuleGroup(node.conditions);
-            }
-            else {
-                condition = parseExpression(node.condition || '');
-            }
-            const body = ((_a = node.body) === null || _a === void 0 ? void 0 : _a.filter((n) => n !== undefined).map(parseNode).join('\n  ')) || '';
-            return `while (${condition}) {\n  ${body}\n}`;
-        }
-        function parseExpression(expr) {
-            if (typeof expr === 'number') {
-                return expr.toString();
-            }
-            else if (typeof expr === 'string' && !isNaN(Number(expr))) {
-                return expr;
-            }
-            else if (typeof expr === 'string') {
-                return /^[a-zA-Z_$][a-zA-Z_$0-9]*$/.test(expr)
-                    ? expr
-                    : JSON.stringify(expr);
-            }
-            else if (typeof expr === 'object' && expr.operation) {
-                const [left, right] = expr.operands.map(parseExpression);
-                // Handle special operators that need different formatting
-                switch (expr.operation) {
-                    case '=':
-                        // Assignment operator - no parentheses needed
-                        return `${left} = ${right}`;
-                    case '==':
-                    case '!=':
-                        // Equality operators - use parentheses for clarity
-                        return `(${left} ${expr.operation} ${right})`;
-                    default:
-                        // All other operators - use parentheses
-                        return `(${left} ${expr.operation} ${right})`;
-                }
-            }
-            else {
-                return JSON.stringify(expr);
-            }
-        }
-        // --- New helper for forLoop ---
-        function parseForLoop(node) {
-            var _a;
-            // Format initialization with 'let' keyword
-            let init = node.init || '';
-            if (init &&
-                !init.startsWith('let ') &&
-                !init.startsWith('const ') &&
-                !init.startsWith('var ')) {
-                // Check if it's an assignment expression (contains '=')
-                if (init.includes('=')) {
-                    init = `let ${init}`;
-                }
-            }
-            // Parse expressions with proper data type handling
-            let condition;
-            // Check if we have multiple conditions (RuleGroup) or single condition
-            if (node.conditions && node.conditions.rules.length > 0) {
-                condition = parseRuleGroup(node.conditions);
-            }
-            else {
-                condition = parseExpression(node.condition || '');
-            }
-            const update = parseExpression(node.update || '');
-            const body = ((_a = node.body) === null || _a === void 0 ? void 0 : _a.filter(Boolean).map((n) => parseNode(n)).join('\n  ')) || '';
-            return `for (${init}; ${condition}; ${update}) {\n  ${body}\n}`;
-        }
-        // --- New helper for try/catch ---
-        function parseTry(node) {
-            var _a;
-            const body = ((_a = node.body) === null || _a === void 0 ? void 0 : _a.filter(Boolean).map((n) => parseNode(n)).join('\n  ')) || '';
-            let catchBlock = '';
-            if (node.catchBlock) {
-                catchBlock = parseCatch(node.catchBlock);
-            }
-            else {
-                console.log('No catch block found in try node:', node);
-            }
-            return `try {\n  ${body}\n}${catchBlock}`;
-        }
-        function parseCatch(node) {
-            var _a;
-            const errorVar = node.errorVar || 'e';
-            const body = ((_a = node.body) === null || _a === void 0 ? void 0 : _a.filter(Boolean).map((n) => parseNode(n)).join('\n  ')) || '';
-            return ` catch (${errorVar}) {\n  ${body}\n}`;
-        }
-        function parseReturn(node) {
-            const value = parseExpression(node.value || '');
-            return `return ${value};`;
-        }
-        function parseSet(node) {
-            const variable = node.variable;
-            const value = parseExpression(node.value || '');
-            return `${variable} = ${value};`;
-        }
-        // --- New helper for switch/case ---
-        function parseSwitch(node) {
-            var _a;
-            const switchValue = node.switchValue || '';
-            const cases = ((_a = node.body) === null || _a === void 0 ? void 0 : _a.filter(Boolean).map((n) => parseCaseNode(n)).join('\n  ')) || '';
-            return `switch (${switchValue}) {\n  ${cases}\n}`;
-        }
-        function parseCaseNode(node) {
-            var _a, _b;
-            // Handle default case
-            if (node.title === 'Default') {
-                // For case nodes, we need to process their body if they have one
-                const body = ((_a = node.body) === null || _a === void 0 ? void 0 : _a.filter(Boolean).map((n) => parseNode(n)).join('\n    ')) || '';
-                return `default:\n    ${body}\n    break;`;
-            }
-            else {
-                // For case nodes, we need to process their body if they have one
-                // Use the title as the case value, or fallback to a generic case
-                const caseValue = node.title || 'value';
-                const body = ((_b = node.body) === null || _b === void 0 ? void 0 : _b.filter(Boolean).map((n) => parseNode(n)).join('\n    ')) || '';
-                return `case '${caseValue}':\n    ${body}\n    break;`;
-            }
-        }
-        function parseApi(node) {
-            // Extract API node properties
-            const method = node.method || 'GET';
-            const url = node.url || '';
-            const headers = node.headers || [];
-            const queryParams = node.queryParams || [];
-            const body = node.requestBody || '';
-            const bodyType = node.bodyType || 'json';
-            const responseVariable = node.responseVariable || 'apiResponse';
-            const responseDataType = node.responseDataType || 'Object';
-            // Generate headers object
-            const headersObj = headers
-                .filter((h) => h.key && h.value)
-                .reduce((acc, h) => {
-                acc[h.key] = h.value;
-                return acc;
-            }, {});
-            // Generate query parameters
-            const queryString = queryParams
-                .filter((q) => q.key && q.value)
-                .map((q) => `${encodeURIComponent(q.key)}=${encodeURIComponent(q.value)}`)
-                .join('&');
-            const fullUrl = queryString ? `${url}?${queryString}` : url;
-            // Build the fetch options object manually for proper formatting
-            let fetchOptions = `{
-    method: "${method.toUpperCase()}"`;
-            // Add headers
-            if (Object.keys(headersObj).length > 0) {
-                fetchOptions += `,
-    headers: {
-      ${Object.entries(headersObj)
-                    .map(([key, value]) => `"${key}": "${value}"`)
-                    .join(',\n      ')}
-    }`;
-            }
-            // Add body for POST, PUT, PATCH
-            if (['POST', 'PUT', 'PATCH'].includes(method.toUpperCase()) && body) {
-                switch (bodyType) {
-                    case 'json':
-                        try {
-                            // Parse the JSON string to validate it, then stringify it properly
-                            const parsedBody = JSON.parse(body);
-                            fetchOptions += `,
-    body: JSON.stringify(${JSON.stringify(parsedBody)})`;
-                        }
-                        catch (_a) {
-                            // If parsing fails, treat as raw string and stringify it
-                            fetchOptions += `,
-    body: JSON.stringify("${body}")`;
-                        }
-                        break;
-                    case 'form-data':
-                        fetchOptions += `,
-    body: new FormData().append('data', '${body}')`;
-                        break;
-                    case 'x-www-form-urlencoded':
-                        try {
-                            const parsedBody = JSON.parse(body);
-                            const formData = new URLSearchParams(parsedBody).toString();
-                            fetchOptions += `,
-    body: "${formData}"`;
-                        }
-                        catch (_b) {
-                            const formData = new URLSearchParams(body).toString();
-                            fetchOptions += `,
-    body: "${formData}"`;
-                        }
-                        break;
-                    case 'raw':
-                        fetchOptions += `,
-    body: "${body}"`;
-                        break;
-                }
-            }
-            fetchOptions += '\n  }';
-            // Generate the complete API call code
-            const apiCall = `const response = await fetch('${fullUrl}', ${fetchOptions});
-
-if (!response.ok) {
-  throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
-}
-
-const ${responseVariable} = await response.${responseDataType === 'String' ? 'text()' : 'json()'};`;
-            return apiCall;
-        }
-        function parseCustomGraphQLQuery(node, customQuery, url, headers, responseVariable, responseDataType) {
-            // Generate headers object
-            const headersObj = headers
-                .filter((h) => h.key && h.value)
-                .reduce((acc, h) => {
-                acc[h.key] = h.value;
-                return acc;
-            }, {});
-            // Build the fetch options object
-            let fetchOptions = `{
-    method: "POST"`;
-            // Add headers
-            if (Object.keys(headersObj).length > 0) {
-                fetchOptions += `,
-    headers: {
-      ${Object.entries(headersObj)
-                    .map(([key, value]) => `"${key}": "${value}"`)
-                    .join(',\n      ')}
-    }`;
-            }
-            else {
-                // Default Content-Type for GraphQL
-                fetchOptions += `,
-    headers: {
-      "Content-Type": "application/json"
-    }`;
-            }
-            // Add body with custom GraphQL query
-            fetchOptions += `,
-    body: JSON.stringify({
-      query: \`${customQuery}\`,
-      variables: {}
-    })`;
-            fetchOptions += '\n  }';
-            // Generate unique variable names to avoid conflicts
-            const responseVarName = `response${Math.random().toString(36).substr(2, 9)}`;
-            const dataVarName = `data${Math.random().toString(36).substr(2, 9)}`;
-            // Generate the complete GraphQL call code
-            const responseMethod = responseDataType === 'String' ? 'text()' : 'json()';
-            const responseAssignment = responseDataType === 'String'
-                ? `const ${responseVariable} = await ${responseVarName}.${responseMethod};`
-                : `const { data: ${dataVarName} } = await ${responseVarName}.${responseMethod};
-const ${responseVariable} = ${dataVarName};`;
-            const graphqlCall = `const ${responseVarName} = await fetch('${url}', ${fetchOptions});
-
-if (!${responseVarName}.ok) {
-  throw new Error(\`HTTP \${${responseVarName}.status}: \${${responseVarName}.statusText}\`);
-}
-
-${responseAssignment}`;
-            return graphqlCall;
-        }
-        function parseGraphQL(node) {
-            // Extract GraphQL node properties
-            const mode = node.graphqlMode || 'normal';
-            const operationType = node.operationType || 'query';
-            const operationName = node.operationName || '';
-            const rootField = node.rootField || 'field';
-            const url = node.url || '';
-            const headers = node.headers || [];
-            const nodeArguments = node.arguments || [];
-            const fields = node.fields || [];
-            const variables = node.variables || [];
-            const responseVariable = node.responseVariable || 'graphqlResponse';
-            const responseDataType = node.responseDataType || 'Object';
-            const customQuery = node.customQuery || '';
-            // If in advanced mode and custom query is provided, use it directly
-            if (mode === 'advanced' && customQuery.trim()) {
-                return parseCustomGraphQLQuery(node, customQuery, url, headers, responseVariable, responseDataType);
-            }
-            // Generate headers object
-            const headersObj = headers
-                .filter((h) => h.key && h.value)
-                .reduce((acc, h) => {
-                acc[h.key] = h.value;
-                return acc;
-            }, {});
-            // Generate variables object and variable declarations
-            const variablesObj = variables
-                .filter((v) => v.key && v.value)
-                .reduce((acc, v) => {
-                // Use variable name without $ prefix for the variables object
-                const varName = v.key.startsWith('$') ? v.key.slice(1) : v.key;
-                // Convert values to proper types based on GraphQL type
-                let value = v.value;
-                if (v.type === 'Int' || v.type === 'Float') {
-                    value = parseFloat(v.value);
-                }
-                else if (v.type === 'Boolean') {
-                    value = v.value === 'true';
-                }
-                else if (v.type === 'ID' && !isNaN(Number(v.value))) {
-                    value = v.value; // Keep as string for ID
-                }
-                acc[varName] = value;
-                return acc;
-            }, {});
-            // Generate variable declarations for the query
-            const variableDeclarations = variables
-                .filter((v) => v.key && v.type)
-                .map((v) => {
-                const varName = v.key.startsWith('$') ? v.key : `$${v.key}`;
-                return `${varName}: ${v.type}`;
-            })
-                .join(', ');
-            const variablesString = variableDeclarations
-                ? `(${variableDeclarations})`
-                : '';
-            // Generate arguments string - use variables if they exist, otherwise use direct values
-            const args = nodeArguments
-                .filter((arg) => arg.key && arg.value)
-                .map((arg) => {
-                // Check if the value is already a variable reference (starts with $)
-                if (arg.value.startsWith('$')) {
-                    return `${arg.key}: ${arg.value}`;
-                }
-                // Check if there's a variable with the same key
-                const matchingVariable = variables.find((v) => v.key === arg.key);
-                if (matchingVariable) {
-                    const varName = matchingVariable.key.startsWith('$')
-                        ? matchingVariable.key
-                        : `$${matchingVariable.key}`;
-                    return `${arg.key}: ${varName}`;
-                }
-                return `${arg.key}: ${arg.value}`;
-            })
-                .join(', ');
-            const argsString = args ? `(${args})` : '';
-            // Generate fields string
-            const fieldsList = fields
-                .filter((field) => field.name)
-                .map((field) => field.name)
-                .join('\n    ');
-            const fieldsString = fieldsList ? ` {\n    ${fieldsList}\n  }` : '';
-            // Build the GraphQL query
-            const operationNameStr = operationName ? ` ${operationName}` : '';
-            const query = `${operationType}${operationNameStr}${variablesString} {\n  ${rootField}${argsString}${fieldsString}\n}`;
-            // Build the fetch options object
-            let fetchOptions = `{
-    method: "POST"`;
-            // Add headers
-            if (Object.keys(headersObj).length > 0) {
-                fetchOptions += `,
-    headers: {
-      ${Object.entries(headersObj)
-                    .map(([key, value]) => `"${key}": "${value}"`)
-                    .join(',\n      ')}
-    }`;
-            }
-            else {
-                // Default Content-Type for GraphQL
-                fetchOptions += `,
-    headers: {
-      "Content-Type": "application/json"
-    }`;
-            }
-            // Add body with GraphQL query and variables
-            fetchOptions += `,
-    body: JSON.stringify({
-      query: \`${query}\`,
-      variables: ${JSON.stringify(variablesObj)}
-    })`;
-            fetchOptions += '\n  }';
-            // Generate unique variable names to avoid conflicts
-            const responseVarName = `response${Math.random().toString(36).substr(2, 9)}`;
-            const dataVarName = `data${Math.random().toString(36).substr(2, 9)}`;
-            // Generate the complete GraphQL call code
-            const responseMethod = responseDataType === 'String' ? 'text()' : 'json()';
-            const responseAssignment = responseDataType === 'String'
-                ? `const ${responseVariable} = await ${responseVarName}.${responseMethod};`
-                : `const { data: ${dataVarName} } = await ${responseVarName}.${responseMethod};
-const ${responseVariable} = ${dataVarName};`;
-            const graphqlCall = `const ${responseVarName} = await fetch('${url}', ${fetchOptions});
-
-if (!${responseVarName}.ok) {
-  throw new Error(\`HTTP \${${responseVarName}.status}: \${${responseVarName}.statusText}\`);
-}
-
-${responseAssignment}`;
-            return graphqlCall;
-        }
-        return parseNode(json);
-    }
-    // Only process root nodes (nodes with no parentId) at the top level
-    const rootNodes = clonedJson.nodes.filter((node) => !node.parentId);
-    const output = rootNodes
-        .map((node) => processNode(node, new Set()))
-        .filter(Boolean);
-    // Find all function nodes instead of just one
-    const allFunctions = output.filter((n) => n.type === 'function');
-    if (allFunctions.length > 0) {
-        // Generate code for each function separately
-        const functionCodes = allFunctions.map((func) => {
-            // Reset processedNodes for each function to avoid conflicts
-            processedNodes.clear();
-            // Find the original function node to get its ID
-            const originalFunctionNode = rootNodes.find((node) => node.id === func.id);
-            if (!originalFunctionNode)
-                return jsonToJavaScript(func);
-            // Find nodes that belong to this specific function by following edges
-            // and exclude nodes that belong to other functions
-            const functionBody = findNodesBelongingToFunction(originalFunctionNode, rootNodes, clonedJson.edges, allFunctions
-                .map((f) => f.id)
-                .filter((id) => id !== undefined));
-            func.body = functionBody;
-            return jsonToJavaScript(func);
-        });
-        const mainCode = functionCodes.join('\n\n');
-        return {
-            externalFunctions: externalFunctions.join('\n'),
-            mainCode: mainCode,
-        };
-    }
-    return { externalFunctions: '', mainCode: '' };
-};
-//# sourceMappingURL=flow-to-js.js.map