@scenario-labs/sdk 2.0.0 → 2.2.0

package/lib/workflow_converter.js

@@ -2,7 +2,24 @@
 // Converts a workflow editor state (nodes + edges) to a flow array suitable for the Scenario API.
 // Ported from fawkes useConvertWorkflowToApp — pure function, no React dependencies.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASPECT_RATIO_PRESETS = void 0;
+exports.normalizeAspectRatio = normalizeAspectRatio;
+exports.getAspectRatioModelInputNames = getAspectRatioModelInputNames;
+exports.getAspectRatioBounds = getAspectRatioBounds;
+exports.getDimensionsFromAspectRatio = getDimensionsFromAspectRatio;
 exports.convertWorkflowEditorToFlow = convertWorkflowEditorToFlow;
+const RUNNABLE_TYPES = new Set(['model', 'llm', 'forEach', 'forEachEnd']);
+exports.ASPECT_RATIO_PRESETS = [
+    '16:9',
+    '3:2',
+    '4:3',
+    '5:4',
+    '1:1',
+    '4:5',
+    '3:4',
+    '2:3',
+    '9:16',
+];
 // ---- Utility functions ----
 function nodeIdToFlowId(nodeId) {
     return nodeId.replace(/\s/g, '');
@@ -33,6 +50,96 @@ function convertValueToList(value) {
 function getConditionalInputHandleId(nodeId) {
     return `${nodeId}-source-conditional`;
 }
+function handleTypeIncludes(handleType, value) {
+    if (Array.isArray(handleType))
+        return handleType.includes(value);
+    return handleType === value;
+}
+function parseAspectRatio(aspectRatio) {
+    if (!aspectRatio)
+        return undefined;
+    const [rawWidth, rawHeight] = aspectRatio.split(':');
+    const width = Number(rawWidth);
+    const height = Number(rawHeight);
+    if (!Number.isFinite(width) ||
+        !Number.isFinite(height) ||
+        width <= 0 ||
+        height <= 0 ||
+        !Number.isInteger(width) ||
+        !Number.isInteger(height)) {
+        return undefined;
+    }
+    return { width, height };
+}
+function getGreatestCommonDivisor(a, b) {
+    let x = Math.abs(Math.trunc(a));
+    let y = Math.abs(Math.trunc(b));
+    while (y) {
+        const temp = y;
+        y = x % y;
+        x = temp;
+    }
+    return x || 1;
+}
+function makeNumberAMultipleOfX(value, multipleOf) {
+    if (multipleOf <= 0)
+        return Math.round(value);
+    return Math.round(value / multipleOf) * multipleOf;
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function normalizeAspectRatio(aspectRatio) {
+    const parsed = parseAspectRatio(aspectRatio);
+    if (!parsed)
+        return undefined;
+    const divisor = getGreatestCommonDivisor(parsed.width, parsed.height);
+    return `${parsed.width / divisor}:${parsed.height / divisor}`;
+}
+function getAspectRatioModelInputNames(model) {
+    if (!model)
+        return {};
+    const widthInputName = model.uiConfig?.resolutionComponent?.widthInput ??
+        model.inputs?.find((input) => input.name === 'width')?.name;
+    const heightInputName = model.uiConfig?.resolutionComponent?.heightInput ??
+        model.inputs?.find((input) => input.name === 'height')?.name;
+    const aspectRatioInputName = model.inputs?.find((input) => input.name === 'aspectRatio')?.name;
+    return { widthInputName, heightInputName, aspectRatioInputName };
+}
+function getAspectRatioBounds(model, { widthInputName, heightInputName }) {
+    if (!model || !widthInputName || !heightInputName)
+        return undefined;
+    const widthInput = model.inputs?.find((input) => input.name === widthInputName);
+    const heightInput = model.inputs?.find((input) => input.name === heightInputName);
+    const presets = model.uiConfig?.resolutionComponent?.presets;
+    const widthPresets = (presets ?? [])
+        .map((preset) => preset.width)
+        .filter((value) => typeof value === 'number');
+    const heightPresets = (presets ?? [])
+        .map((preset) => preset.height)
+        .filter((value) => typeof value === 'number');
+    const multipleOf = widthInput?.step ?? 8;
+    return {
+        maxWidth: widthInput?.max ?? (widthPresets.length > 0 ? Math.max(...widthPresets) : 2048),
+        minWidth: widthInput?.min ?? (widthPresets.length > 0 ? Math.min(...widthPresets) : 64),
+        maxHeight: heightInput?.max ?? (heightPresets.length > 0 ? Math.max(...heightPresets) : 2048),
+        minHeight: heightInput?.min ?? (heightPresets.length > 0 ? Math.min(...heightPresets) : 64),
+        multipleOf,
+    };
+}
+function getDimensionsFromAspectRatio(args) {
+    const parsed = parseAspectRatio(args.aspectRatio);
+    if (!parsed)
+        return undefined;
+    const ratio = parsed.width / parsed.height;
+    let width = ratio >= 1 ? args.bounds.maxWidth : Math.round(args.bounds.maxHeight * ratio);
+    let height = ratio >= 1 ? Math.round(args.bounds.maxWidth / ratio) : args.bounds.maxHeight;
+    width = makeNumberAMultipleOfX(width, args.bounds.multipleOf);
+    height = makeNumberAMultipleOfX(height, args.bounds.multipleOf);
+    width = clamp(width, args.bounds.minWidth, args.bounds.maxWidth);
+    height = clamp(height, args.bounds.minHeight, args.bounds.maxHeight);
+    return { width, height };
+}
 function getForEachFlowListInputDescriptor(args) {
     const { listProvider, outputHandle, inputIndex } = args;
     const isText = listProvider?.type === 'splitText' ||
@@ -260,11 +367,11 @@ function toStaticInput(name, type, value) {
         return undefined;
     return { name, type, value: value };
 }
-function isFormArray(value) {
+function getIsFormArray(value) {
     return (Array.isArray(value) &&
         value.every((item) => typeof item === 'object' && item !== null && !Array.isArray(item)));
 }
-function isModelCompose(model) {
+function getIsModelCompose(model) {
     return !!model?.id && (model.tags ?? []).includes('compose');
 }
 function getIsConditionallyExecuted(targetNodeId, nodes, edges) {
@@ -274,6 +381,87 @@ function getIsConditionallyExecuted(targetNodeId, nodes, edges) {
         return (e.source === targetNodeId && e.sourceHandle === conditionalHandleId && sourceNode?.type === 'ifElse');
     });
 }
+function buildDimensionLookupCEL(args) {
+    let expression = String(args.fallback);
+    for (let i = args.presets.length - 1; i >= 0; i--) {
+        const preset = args.presets[i];
+        expression = `trim(${args.variable}) == '${preset.aspectRatio}' ? ${preset[args.dimension]} : ${expression}`;
+    }
+    return expression;
+}
+function applyAspectRatioInputs(args) {
+    const modelInputNames = getAspectRatioModelInputNames(args.model);
+    const modelBounds = getAspectRatioBounds(args.model, modelInputNames);
+    const { widthInputName, heightInputName, aspectRatioInputName } = modelInputNames;
+    if (aspectRatioInputName) {
+        const transformId = `${args.flowId}_aspectRatio_value`;
+        args.flow.push({
+            id: transformId,
+            type: 'transform',
+            logic: { transform: 'trim(aspectRatio)' },
+            inputs: [{ name: 'aspectRatio', type: 'string', ref: args.aspectRatioRef }],
+        });
+        setOrPushFlowInput(args.flowInputs, args.flowInputs.findIndex((inp) => inp.name === aspectRatioInputName), {
+            name: aspectRatioInputName,
+            type: 'string',
+            ref: { node: transformId, name: 'all' },
+        });
+    }
+    if (widthInputName && heightInputName && modelBounds) {
+        const presetDimensions = exports.ASPECT_RATIO_PRESETS.flatMap((preset) => {
+            const dims = getDimensionsFromAspectRatio({ aspectRatio: preset, bounds: modelBounds });
+            if (!dims)
+                return [];
+            const normalized = normalizeAspectRatio(preset);
+            if (!normalized)
+                return [];
+            return [{ aspectRatio: normalized, ...dims }];
+        });
+        const fallbackDimensions = presetDimensions.find((preset) => preset.aspectRatio === '1:1') ??
+            presetDimensions[0] ?? {
+            width: modelBounds.maxWidth,
+            height: modelBounds.maxHeight,
+        };
+        const widthTransformId = `${args.flowId}_aspectRatio_width`;
+        const heightTransformId = `${args.flowId}_aspectRatio_height`;
+        args.flow.push({
+            id: widthTransformId,
+            type: 'transform',
+            logic: {
+                transform: buildDimensionLookupCEL({
+                    variable: 'aspectRatio',
+                    presets: presetDimensions,
+                    dimension: 'width',
+                    fallback: fallbackDimensions.width,
+                }),
+            },
+            inputs: [{ name: 'aspectRatio', type: 'string', ref: args.aspectRatioRef }],
+        });
+        args.flow.push({
+            id: heightTransformId,
+            type: 'transform',
+            logic: {
+                transform: buildDimensionLookupCEL({
+                    variable: 'aspectRatio',
+                    presets: presetDimensions,
+                    dimension: 'height',
+                    fallback: fallbackDimensions.height,
+                }),
+            },
+            inputs: [{ name: 'aspectRatio', type: 'string', ref: args.aspectRatioRef }],
+        });
+        setOrPushFlowInput(args.flowInputs, args.flowInputs.findIndex((inp) => inp.name === widthInputName), {
+            name: widthInputName,
+            type: 'number',
+            ref: { node: widthTransformId, name: 'all' },
+        });
+        setOrPushFlowInput(args.flowInputs, args.flowInputs.findIndex((inp) => inp.name === heightInputName), {
+            name: heightInputName,
+            type: 'number',
+            ref: { node: heightTransformId, name: 'all' },
+        });
+    }
+}
 function getForEachBodyEditorNodeIds(forEachId, forEachEndId, edges) {
     const bodyNodeIds = new Set();
     const queue = [];
@@ -325,7 +513,6 @@ function getNodeOutputValue(node, targetHandleId) {
     }
     return undefined;
 }
-const RUNNABLE_TYPES = new Set(['model', 'llm', 'forEach', 'forEachEnd']);
 function internalGetConnectedNodes(nodes, edges, startNodeId, direction, isStoppingAtRunnableNodes) {
     const nodesById = new Map(nodes.map((n) => {
         const meta = { id: n.id, type: n.type };
@@ -365,42 +552,44 @@ function internalGetConnectedNodes(nodes, edges, startNodeId, direction, isStopp
     const idSet = new Set(ids);
     return nodes.filter((n) => idSet.has(n.id));
 }
+function resolveIfElseConditionField(field, candidateNodes) {
+    const byExactId = candidateNodes.find((n) => n.id === field);
+    if (byExactId)
+        return { nodeId: field };
+    for (const node of candidateNodes) {
+        for (const handle of node.data.outputHandles ?? []) {
+            if (`${node.id}_${handle.name}` === field) {
+                return { nodeId: node.id, targetHandleId: handle.id };
+            }
+        }
+    }
+    return undefined;
+}
 function normalizeNodes(nodes) {
     return nodes.map((node) => {
         if (node.type !== 'model' && node.type !== 'llm')
             return node;
-        const hasType = (t, v) => Array.isArray(t) ? t.includes(v) : t === v;
         const inputHandles = (node.data.inputHandles ?? [])
             .flatMap((h) => (h.subHandles ? h.subHandles : [h]))
-            .filter((h) => hasType(h.type, 'conditional') ||
-            hasType(h.type, 'prompt') ||
-            hasType(h.type, 'image') ||
-            hasType(h.type, 'video') ||
-            hasType(h.type, '3d') ||
-            hasType(h.type, 'audio') ||
+            .filter((h) => handleTypeIncludes(h.type, 'conditional') ||
+            handleTypeIncludes(h.type, 'aspectRatio') ||
+            handleTypeIncludes(h.type, 'prompt') ||
+            handleTypeIncludes(h.type, 'image') ||
+            handleTypeIncludes(h.type, 'video') ||
+            handleTypeIncludes(h.type, '3d') ||
+            handleTypeIncludes(h.type, 'audio') ||
             (node.type === 'llm' && h.name === 'textInputs'));
         return { ...node, data: { ...node.data, inputHandles } };
     });
 }
-// ---- Main function ----
-/**
- * Converts a workflow editor state (nodes, edges, inputKeys) into a flow array
- * ready to be passed to `client.workflows.update({ flow: ... })`.
- *
- * @example
- * ```ts
- * const flow = convertWorkflowEditorToFlow({ nodes, edges, inputKeys, getModel });
- * await client.workflows.update(workflowId, { flow: flow as WorkflowUpdateParams.Flow[] });
- * ```
- */
 function convertWorkflowEditorToFlow(params) {
     const { edges, inputKeys } = params;
     const nodes = normalizeNodes(params.nodes);
     const inputNodeIds = nodes.filter((n) => !!n.data.isInput).map((n) => n.id);
-    const selectedOutputNodes = nodes.filter((n) => (n.type === 'model' || n.type === 'forEachEnd') && !!n.data.isOutput);
+    const selectedOutputNodes = nodes.filter((n) => (n.type === 'model' || n.type === 'forEachEnd' || n.type === 'llm') && !!n.data.isOutput);
     const selectedOutputNodeIds = selectedOutputNodes.map((n) => n.id);
     const selectedOutputModelNodeIds = new Set(selectedOutputNodes
-        .filter((n) => n.type === 'model')
+        .filter((n) => n.type === 'model' || n.type === 'llm')
         .map((n) => n.id));
     // Collect all nodes in branches that lead to selected outputs
     const nodesInSelectedBranches = new Set();
@@ -434,6 +623,12 @@ function convertWorkflowEditorToFlow(params) {
         .filter((n) => !inputNodeIds.includes(n.id) && n.type !== 'forEachEnd')
         .map((n) => [n.id, nodeIdToFlowId(n.id)]));
     const nodeIdToInputNameMap = new Map(inputNodeIds.map((id) => [id, nodeIdToFlowId(id)]));
+    const approvalByApprovedNodeId = buildApprovalByApprovedNodeIdMap({
+        nodes,
+        edges,
+        nodesInSelectedBranches,
+        selectedOutputNodeIds,
+    });
     const nodeHandleTransformMap = new Map();
     const ctx = {
         nodes,
@@ -507,6 +702,7 @@ function convertWorkflowEditorToFlow(params) {
             const model = remoteModel === 'unknown' ? undefined : remoteModel;
             const modelInputs = model?.inputs;
             const conditionalHandleId = getConditionalInputHandleId(node.id);
+            const aspectRatioEdges = [];
             const edgesByInput = new Map();
             for (const edge of incomingEdges) {
                 if (edge.sourceHandle === conditionalHandleId)
@@ -514,6 +710,10 @@ function convertWorkflowEditorToFlow(params) {
                 const handle = getInputHandle(edge, node.data.inputHandles);
                 if (!handle?.name)
                     continue;
+                if (handleTypeIncludes(handle.type, 'aspectRatio')) {
+                    aspectRatioEdges.push(edge);
+                    continue;
+                }
                 const existing = edgesByInput.get(handle.name);
                 if (existing)
                     existing.push(edge);
@@ -526,7 +726,7 @@ function convertWorkflowEditorToFlow(params) {
                         continue;
                     const modelInput = modelInputs?.find((inp) => inp.name === key);
                     if (modelInput?.type === 'inputs_array') {
-                        if (!isFormArray(value))
+                        if (!getIsFormArray(value))
                             continue;
                         const nestedInputs = modelInput.inputs ?? [];
                         const items = [];
@@ -547,7 +747,7 @@ function convertWorkflowEditorToFlow(params) {
                                         itemInputs.push(inp);
                                 }
                             }
-                            const isValid = isModelCompose(model) ? getHasComposeLayerSourceInput(itemInputs) : itemInputs.length > 0;
+                            const isValid = getIsModelCompose(model) ? getHasComposeLayerSourceInput(itemInputs) : itemInputs.length > 0;
                             if (isValid)
                                 items.push(itemInputs);
                         }
@@ -565,6 +765,18 @@ function convertWorkflowEditorToFlow(params) {
                     }
                 }
             }
+            if (aspectRatioEdges.length > 0 && model) {
+                const aspectRatioRef = getSourceRef(aspectRatioEdges[0], ctx);
+                if (aspectRatioRef) {
+                    applyAspectRatioInputs({
+                        flow,
+                        flowInputs,
+                        flowId,
+                        aspectRatioRef,
+                        model,
+                    });
+                }
+            }
             for (const [inputName, inputEdges] of edgesByInput) {
                 const existingIndex = flowInputs.findIndex((inp) => inp.name === inputName);
                 const modelInput = modelInputs?.find((inp) => inp.name === inputName);
@@ -625,7 +837,7 @@ function convertWorkflowEditorToFlow(params) {
                             const isArr = targetInputType === 'file_array';
                             const isRequired = (targetNode?.type === 'asset' &&
                                 !!targetNode.data.isRequired) ||
-                                isModelCompose(model);
+                                getIsModelCompose(model);
                             transformVariables.push({ name: targetNodeKey, isArray: isArr, isRequired });
                             if (!targetNode?.data.isInput &&
                                 (targetNode?.type === 'asset' || targetNode?.type === 'text')) {
@@ -696,7 +908,9 @@ function convertWorkflowEditorToFlow(params) {
                 type: 'custom-model',
                 modelId: nodeData.modelId,
                 inputs: flowInputs.length > 0 ? flowInputs : undefined,
-                includeOutputsInWorkflowJob: node.type === 'model' && selectedOutputModelNodeIds.has(node.id) ? true : undefined,
+                includeOutputsInWorkflowJob: (node.type === 'model' || node.type === 'llm') && selectedOutputModelNodeIds.has(node.id) ?
+                    true
+                    : undefined,
             });
             ensureInputVideoTransformsAdded();
             if (node.type === 'model' && node.data.type === 'video') {
@@ -759,6 +973,19 @@ function convertWorkflowEditorToFlow(params) {
                 addVideoFirstLastFrameTransforms(node.id, flowId, node, edges, flow, nodeHandleTransformMap);
             }
             // ------------------------------------
+            // AspectRatio -> transform with ratio literal
+            // ------------------------------------
+        }
+        else if (node.type === 'aspectRatio') {
+            const flowInputs = collectConditionalConnectionInputs(incomingEdges, node.id, ctx);
+            const value = node.data.output || '1:1';
+            flow.push({
+                id: flowId,
+                type: 'transform',
+                logic: { transform: `'${escapeCELString(value)}'` },
+                inputs: flowInputs.length > 0 ? flowInputs : undefined,
+            });
+            // ------------------------------------
             // TransformText -> transform (CEL)
             // ------------------------------------
         }
@@ -837,7 +1064,7 @@ function convertWorkflowEditorToFlow(params) {
                     continue;
                 const outHandle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
                 const outHandleName = outHandle?.name ?? 'output';
-                const varName = getOutputHandleVarName(targetNode.id, outHandleName);
+                const varName = `${targetNode.id}_${outHandleName}`;
                 const isArr = (targetNode.type === 'asset' && !!targetNode.data.isMultiple) ||
                     targetNode.type === 'groupItems' ||
                     targetNode.type === 'sliceAssets' ||
@@ -946,17 +1173,47 @@ function convertWorkflowEditorToFlow(params) {
                         fieldsUsed.add(condition.field);
                 }
             }
-            for (const fieldNodeId of fieldsUsed) {
+            const edgesIntoIfElse = edges.filter((e) => e.target === node.id);
+            for (const fieldKey of fieldsUsed) {
+                const resolved = resolveIfElseConditionField(fieldKey, nodes);
+                const fieldNodeId = resolved?.nodeId;
+                if (!fieldNodeId)
+                    continue;
+                const outputHandleName = resolved?.targetHandleId !== undefined ?
+                    nodes
+                        .find((n) => n.id === fieldNodeId)
+                        ?.data.outputHandles?.find((h) => h.id === resolved.targetHandleId)?.name ?? 'output'
+                    : 'output';
+                const celVarName = getOutputHandleVarName(fieldNodeId, outputHandleName);
+                nodeIdToInputNameMap.set(fieldKey, celVarName);
+                const edgeToIfElse = edgesIntoIfElse
+                    .filter((e) => e.source === fieldNodeId)
+                    .find((e) => {
+                    if (resolved.targetHandleId === undefined)
+                        return true;
+                    return e.sourceHandle === resolved.targetHandleId;
+                }) ?? edgesIntoIfElse.find((e) => e.source === fieldNodeId);
                 if (inputNodeIds.includes(fieldNodeId)) {
-                    const inputName = nodeIdToInputNameMap.get(fieldNodeId);
-                    if (inputName)
-                        flowInputs.push({ name: inputName, type: 'string', ref: { node: 'workflow', name: inputName } });
+                    const workflowInputName = nodeIdToInputNameMap.get(fieldNodeId);
+                    if (workflowInputName) {
+                        const ref = edgeToIfElse ?
+                            getSourceRef(edgeToIfElse, ctx)
+                            : { node: 'workflow', name: workflowInputName };
+                        flowInputs.push({
+                            name: celVarName,
+                            type: 'string',
+                            ref: ref ?? { node: 'workflow', name: workflowInputName },
+                        });
+                    }
                 }
                 else {
+                    const refFromEdge = edgeToIfElse ? getSourceRef(edgeToIfElse, ctx) : undefined;
                     const targetFlowId = nodeIdToFlowIdMap.get(fieldNodeId);
-                    if (targetFlowId) {
-                        flowInputs.push({ name: targetFlowId, type: 'string', ref: { node: targetFlowId, name: 'all' } });
-                        nodeIdToInputNameMap.set(fieldNodeId, targetFlowId);
+                    if (refFromEdge) {
+                        flowInputs.push({ name: celVarName, type: 'string', ref: refFromEdge });
+                    }
+                    else if (targetFlowId) {
+                        flowInputs.push({ name: celVarName, type: 'string', ref: { node: targetFlowId, name: 'all' } });
                     }
                 }
             }
@@ -990,6 +1247,64 @@ function convertWorkflowEditorToFlow(params) {
     for (const [forEachId, forEachFlowItem] of forEachFlowItemRefs) {
         forEachFlowItem.loopBodyNodeIds = forEachLoopFlowIds.get(forEachId) ?? [];
     }
+    applyApprovalsToFlow({ flow, edges, approvalByApprovedNodeId, nodeIdToFlowIdMap });
     return flow;
 }
+function buildApprovalByApprovedNodeIdMap({ nodes, edges, nodesInSelectedBranches, selectedOutputNodeIds, }) {
+    const result = new Map();
+    for (const approvalNode of nodes) {
+        if (approvalNode.type !== 'approval')
+            continue;
+        const approvalEdge = edges.find((e) => e.source === approvalNode.id && e.sourceHandle === `${approvalNode.id}-source-approval`);
+        if (!approvalEdge)
+            continue;
+        const approvedNodeId = approvalEdge.target;
+        if (!nodesInSelectedBranches.has(approvedNodeId) && !selectedOutputNodeIds.includes(approvedNodeId))
+            continue;
+        const approvedNode = nodes.find((n) => n.id === approvedNodeId);
+        if (!approvedNode)
+            continue;
+        const approvedFlowId = approvedNode.type === 'forEachEnd' ?
+            approvedNode.data.parentNodeId ?
+                nodeIdToFlowId(approvedNode.data.parentNodeId)
+                : undefined
+            : nodeIdToFlowId(approvedNodeId);
+        if (!approvedFlowId)
+            continue;
+        result.set(approvedNodeId, {
+            approvalFlowId: nodeIdToFlowId(approvalNode.id),
+            approvedFlowId,
+            message: approvalNode.data.message ?? '',
+        });
+    }
+    return result;
+}
+function applyApprovalsToFlow({ flow, edges, approvalByApprovedNodeId, nodeIdToFlowIdMap, }) {
+    if (approvalByApprovedNodeId.size === 0)
+        return;
+    const flowIdToWorkflowNodeId = new Map([...nodeIdToFlowIdMap.entries()].map(([nodeId, flowId]) => [flowId, nodeId]));
+    for (const flowItem of flow) {
+        const workflowNodeId = flowIdToWorkflowNodeId.get(flowItem.id);
+        if (!workflowNodeId)
+            continue;
+        const dependsOn = new Set(flowItem.dependsOn ?? []);
+        const incomingEdges = edges.filter((e) => e.source === workflowNodeId &&
+            !e.data?.isForEachEndEdge);
+        for (const edge of incomingEdges) {
+            const approval = approvalByApprovedNodeId.get(edge.target);
+            if (approval)
+                dependsOn.add(approval.approvalFlowId);
+        }
+        if (dependsOn.size > 0)
+            flowItem.dependsOn = [...dependsOn].sort();
+    }
+    for (const approvalInfo of approvalByApprovedNodeId.values()) {
+        flow.push({
+            id: approvalInfo.approvalFlowId,
+            type: 'user-approval',
+            dependsOn: [approvalInfo.approvedFlowId],
+            label: approvalInfo.message,
+        });
+    }
+}
 //# sourceMappingURL=workflow_converter.js.map