@flowuent-org/diagramming-core 1.0.8 → 1.1.0

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

@@ -0,0 +1,1132 @@
+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