@uipath/flow-tool 1.202.2 → 1.203.0-preview.180

package/dist/{packager-tool-tv33t02p.js → packager-tool-pszx10r5.js}

@@ -1,21 +1,21 @@
 import {
   enableErrorHandlingForErrorEdges,
   expandHandleIds
-} from "./packager-tool-nq4rcqqg.js";
+} from "./packager-tool-1frs4sr4.js";
 import {
   readFlowWorkflow,
   writeFlowWorkflow
-} from "./packager-tool-n7x6kxph.js";
+} from "./packager-tool-w22107ex.js";
 import {
   DEFAULT_LAYOUT_OPTIONS,
   GRID_SPACING,
   resolveHeight,
   resolveWidth,
   snapToGrid
-} from "./packager-tool-29eg86w6.js";
+} from "./packager-tool-6rsegsby.js";
 import {
   generateNodeVariables
-} from "./packager-tool-jjpc0yka.js";
+} from "./packager-tool-vcjq9xkc.js";
 import {
   __require,
   __toESM
@@ -437,11 +437,187 @@ var ElkLayoutEngine = class {
     return { totalWidth: maxX - minX, totalHeight: maxY - minY, executionTime };
   }
 };
+var SPINE_STRAIGHTNESS_PRIORITY = "1";
+function findSpineEdgeIds(childIds, edges) {
+  if (childIds.length === 0 || edges.length === 0)
+    return /* @__PURE__ */ new Set;
+  const idSet = new Set(childIds);
+  const outDegree = new Map(childIds.map((id) => [id, 0]));
+  const inDegree = new Map(childIds.map((id) => [id, 0]));
+  for (const e of edges) {
+    const src = e.sources[0];
+    const tgt = e.targets[0];
+    if (!idSet.has(src) || !idSet.has(tgt) || src === tgt)
+      continue;
+    outDegree.set(src, (outDegree.get(src) ?? 0) + 1);
+    inDegree.set(tgt, (inDegree.get(tgt) ?? 0) + 1);
+  }
+  const spine = /* @__PURE__ */ new Set;
+  for (const e of edges) {
+    const src = e.sources[0];
+    const tgt = e.targets[0];
+    if (!idSet.has(src) || !idSet.has(tgt) || src === tgt)
+      continue;
+    if ((outDegree.get(src) ?? 0) === 1 && (inDegree.get(tgt) ?? 0) === 1) {
+      spine.add(e.id);
+    }
+  }
+  return spine;
+}
+function buildTidyElkContainer(containerId, params) {
+  const directChildren = params.childrenByParent.get(containerId) ?? [];
+  const localEdges = params.edgesByParent.get(containerId) ?? [];
+  const elkChildren = directChildren.map((child) => {
+    if (child.isContainer)
+      return buildTidyElkContainer(child.id, params);
+    const oh = params.overhangById?.get(child.id);
+    return {
+      id: child.id,
+      width: child.width + (oh?.left ?? 0) + (oh?.right ?? 0),
+      height: child.height + (oh?.top ?? 0) + (oh?.bottom ?? 0)
+    };
+  });
+  const spineEdgeIds = findSpineEdgeIds(directChildren.map((c) => c.id), localEdges);
+  const annotatedEdges = localEdges.map((e) => spineEdgeIds.has(e.id) ? { ...e, layoutOptions: { ...e.layoutOptions, "org.eclipse.elk.layered.priority.straightness": SPINE_STRAIGHTNESS_PRIORITY } } : e);
+  return {
+    id: containerId,
+    width: params.fit.minWidth,
+    height: params.fit.minHeight,
+    layoutOptions: {
+      "elk.algorithm": "layered",
+      "elk.direction": params.direction,
+      "elk.padding": params.fit.elkPadding,
+      "elk.spacing.nodeNode": String(params.nodeSpacing),
+      "elk.layered.spacing.nodeNodeBetweenLayers": String(params.layerSpacing),
+      "elk.layered.nodePlacement.strategy": "BRANDES_KOEPF",
+      "elk.layered.nodePlacement.bk.fixedAlignment": "BALANCED",
+      "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES",
+      "elk.layered.crossingMinimization.forceNodeModelOrder": "true",
+      ...params.orthogonalRouting ? { "elk.edgeRouting": "ORTHOGONAL" } : {},
+      "elk.hierarchyHandling": "SEPARATE_CHILDREN",
+      "elk.nodeSize.constraints": "MINIMUM_SIZE",
+      "elk.nodeSize.minimum": `(${params.fit.minWidth},${params.fit.minHeight})`
+    },
+    children: elkChildren,
+    edges: annotatedEdges
+  };
+}
+function clamp(value, lo, hi) {
+  if (hi < lo)
+    return lo;
+  return Math.min(hi, Math.max(lo, value));
+}
+function applyTidyContainerLayout(node, updates, containerOffsets, params) {
+  const { fit } = params;
+  const horizontal = params.direction === "RIGHT" || params.direction === "LEFT";
+  const children = node.children ?? [];
+  const isContainerElkNode = node.layoutOptions !== undefined;
+  if (children.length === 0) {
+    if (isContainerElkNode) {
+      const w = params.snapUp(Math.max(fit.minWidth, node.width ?? 0));
+      const h = params.snapUp(Math.max(fit.minHeight, node.height ?? 0));
+      updates.set(node.id, { width: w, height: h });
+      return { width: w, height: h };
+    }
+    return { width: node.width ?? params.defaultNodeSize, height: node.height ?? params.defaultNodeSize };
+  }
+  const childSizes = /* @__PURE__ */ new Map;
+  for (const child of children) {
+    childSizes.set(child.id, applyTidyContainerLayout(child, updates, containerOffsets, params));
+  }
+  const childAnchorAdjustments = horizontal && params.hooks?.resolveChildAnchorAdjustments ? params.hooks.resolveChildAnchorAdjustments(node.id, children, childSizes) : /* @__PURE__ */ new Map;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = 0;
+  let maxY = 0;
+  for (const child of children) {
+    const x = child.x ?? 0;
+    const y = (child.y ?? 0) + (childAnchorAdjustments.get(child.id) ?? 0);
+    const { width: w, height: h } = childSizes.get(child.id);
+    if (x < minX)
+      minX = x;
+    if (y < minY)
+      minY = y;
+    if (x + w > maxX)
+      maxX = x + w;
+    if (y + h > maxY)
+      maxY = y + h;
+  }
+  const bboxWidth = maxX - minX;
+  const bboxHeight = maxY - minY;
+  const finalWidth = params.snapUp(Math.max(fit.minWidth, bboxWidth + fit.paddingLeft + fit.paddingRight));
+  const baseHeight = params.snapUp(Math.max(fit.minHeight, bboxHeight + fit.paddingTop + fit.paddingBottom));
+  const dxTarget = (finalWidth - bboxWidth) / 2 - minX;
+  const dx = clamp(dxTarget, fit.paddingLeft - minX, finalWidth - fit.paddingRight - maxX);
+  const entryRailY = horizontal && params.hooks?.resolveEntryRail ? params.hooks.resolveEntryRail(node.id, children, childSizes, childAnchorAdjustments) : undefined;
+  let finalHeight = baseHeight;
+  let dy = clamp((finalHeight - bboxHeight) / 2 - minY, fit.paddingTop - minY, finalHeight - fit.paddingBottom - maxY);
+  if (typeof entryRailY === "number") {
+    finalHeight = params.snapUp(Math.max(baseHeight, 2 * (fit.paddingTop - minY + entryRailY), 2 * (maxY - entryRailY + fit.paddingBottom)));
+    dy = finalHeight / 2 - entryRailY;
+  }
+  containerOffsets.set(node.id, { dx, dy });
+  updates.set(node.id, { width: finalWidth, height: finalHeight });
+  for (const child of children) {
+    const size = childSizes.get(child.id);
+    const oh = params.overhangById?.get(child.id);
+    const offsetX = oh?.left ?? 0;
+    const offsetY = oh?.top ?? 0;
+    const realWidth = size.width - offsetX - (oh?.right ?? 0);
+    const realHeight = size.height - offsetY - (oh?.bottom ?? 0);
+    updates.set(child.id, {
+      position: {
+        x: snapToGrid((child.x ?? 0) + dx + offsetX),
+        y: snapToGrid((child.y ?? 0) + (childAnchorAdjustments.get(child.id) ?? 0) + dy + offsetY)
+      },
+      width: realWidth,
+      height: realHeight
+    });
+  }
+  return { width: finalWidth, height: finalHeight };
+}
+async function tidyContainerHierarchy(params) {
+  const root = buildTidyElkContainer(params.containerId, params);
+  const layouted = await params.layout(root);
+  const updates = /* @__PURE__ */ new Map;
+  const containerOffsets = /* @__PURE__ */ new Map;
+  applyTidyContainerLayout(layouted, updates, containerOffsets, params);
+  return { layouted, updates, containerOffsets };
+}
+function snapUpToGrid(value, gridSize = GRID_SPACING) {
+  return Math.ceil(value / gridSize) * gridSize;
+}
+var DEFAULT_INTERIOR_NODE_SPACING = 32;
+var DEFAULT_INTERIOR_LAYER_SPACING = 64;
+var DEFAULT_MIN_WIDTH = 560;
+var DEFAULT_MIN_HEIGHT = 320;
+var DEFAULT_PADDING_TOP = 96;
+var DEFAULT_PADDING_BOTTOM = 48;
+var DEFAULT_PADDING_LEFT = 144;
+var DEFAULT_PADDING_RIGHT = 144;
+function defaultContainerFit() {
+  return {
+    minWidth: DEFAULT_MIN_WIDTH,
+    minHeight: DEFAULT_MIN_HEIGHT,
+    paddingTop: DEFAULT_PADDING_TOP,
+    paddingBottom: DEFAULT_PADDING_BOTTOM,
+    paddingLeft: DEFAULT_PADDING_LEFT,
+    paddingRight: DEFAULT_PADDING_RIGHT,
+    elkPadding: `[top=${DEFAULT_PADDING_TOP},left=${DEFAULT_PADDING_LEFT},bottom=${DEFAULT_PADDING_BOTTOM},right=${DEFAULT_PADDING_RIGHT}]`
+  };
+}
 
 // src/services/tidy-service.ts
 var COLLAPSED_NODE_SIZE = 96;
 var EXPANDED_RECTANGLE_WIDTH = 288;
-var CONTAINER_SIZE = { width: 560, height: 320 };
+var CONTAINER_SIZE = {
+  width: defaultContainerFit().minWidth,
+  height: defaultContainerFit().minHeight
+};
+function parentIdOf(node) {
+  const pid = node?.parentId;
+  return typeof pid === "string" && pid.length > 0 ? pid : undefined;
+}
 function expandedSizeForShape(shape) {
   if (shape === "container") {
     return { ...CONTAINER_SIZE };
@@ -625,6 +801,9 @@ function applyLayoutToNodes(nodes, layoutedNodes, shapeOf) {
   let repositioned = 0;
   let resized = 0;
   for (const node of nodes) {
+    if (UI_ONLY_NODE_TYPES.has(node.type)) {
+      continue;
+    }
     const newPos = positionMap.get(node.id);
     if (!newPos)
       continue;
@@ -634,9 +813,6 @@ function applyLayoutToNodes(nodes, layoutedNodes, shapeOf) {
       node.ui.position = { x: newPos.x, y: newPos.y };
       repositioned++;
     }
-    if (UI_ONLY_NODE_TYPES.has(node.type)) {
-      continue;
-    }
     const targetSize = expandedSizeForShape(shapeOf(node));
     const currentSize = node.ui.size;
     const sizeNeedsUpdate = currentSize?.width !== targetSize.width || currentSize?.height !== targetSize.height;
@@ -647,23 +823,140 @@ function applyLayoutToNodes(nodes, layoutedNodes, shapeOf) {
   }
   return { repositioned, resized };
 }
+function applyContainerLayout(nodes, childRelPositions, nodeSizes) {
+  let repositioned = 0;
+  let resized = 0;
+  for (const node of nodes) {
+    const rel = childRelPositions.get(node.id);
+    if (rel && (node.ui.position.x !== rel.x || node.ui.position.y !== rel.y)) {
+      node.ui.position = { x: rel.x, y: rel.y };
+      repositioned++;
+    }
+    const size = nodeSizes.get(node.id);
+    if (size && (node.ui.size?.width !== size.width || node.ui.size?.height !== size.height)) {
+      node.ui.size = size;
+      resized++;
+    }
+  }
+  return { repositioned, resized };
+}
 async function tidyNodesAndEdges(engine, nodes, edges, portResolver, shapeOf) {
   if (nodes.length === 0) {
     return { repositioned: 0, resized: 0 };
   }
   const allNodes = nodesToLayoutNodes(nodes, shapeOf);
   const allEdges = edgesToLayoutEdges(edges);
+  const nodeIds = new Set(allNodes.map((n) => n.id));
+  const layoutNodeById = new Map(allNodes.map((n) => [n.id, n]));
+  const nodeInstanceOf = (id) => id === undefined ? undefined : layoutNodeById.get(id)?.data;
+  const isContainerId = (id) => {
+    const inst = nodeInstanceOf(id);
+    return inst !== undefined && shapeOf(inst) === "container";
+  };
+  const chainTerminates = (id) => {
+    const seen = new Set;
+    let cur = id;
+    while (cur !== undefined) {
+      if (seen.has(cur))
+        return false;
+      seen.add(cur);
+      const p = parentIdOf(nodeInstanceOf(cur));
+      if (p === undefined || !nodeIds.has(p))
+        return true;
+      cur = p;
+    }
+    return true;
+  };
+  const childrenByParent = new Map;
+  for (const n of allNodes) {
+    if (UI_ONLY_NODE_TYPES.has(n.type))
+      continue;
+    const pid = parentIdOf(n.data);
+    if (pid && pid !== n.id && nodeIds.has(pid) && isContainerId(pid) && chainTerminates(n.id)) {
+      const group = childrenByParent.get(pid);
+      if (group)
+        group.push(n);
+      else
+        childrenByParent.set(pid, [n]);
+    }
+  }
+  const containerChildIds = new Set([...childrenByParent.values()].flat().map((n) => n.id));
+  const interiorEdgesByParent = new Map;
+  for (const e of allEdges) {
+    const sp = parentIdOf(nodeInstanceOf(e.source));
+    const tp = parentIdOf(nodeInstanceOf(e.target));
+    if (sp && sp === tp) {
+      const list = interiorEdgesByParent.get(sp);
+      if (list)
+        list.push(e);
+      else
+        interiorEdgesByParent.set(sp, [e]);
+    }
+  }
+  const tidyChildrenByParent = new Map;
+  for (const [pid, kids] of childrenByParent) {
+    tidyChildrenByParent.set(pid, kids.map((k) => ({
+      id: k.id,
+      width: k.width ?? COLLAPSED_NODE_SIZE,
+      height: k.height ?? COLLAPSED_NODE_SIZE,
+      isContainer: childrenByParent.has(k.id)
+    })));
+  }
+  const elkEdgesByParent = new Map;
+  for (const [pid, es] of interiorEdgesByParent) {
+    elkEdgesByParent.set(pid, es.map((e) => ({
+      id: e.id,
+      sources: [e.source],
+      targets: [e.target]
+    })));
+  }
+  const childRelPositions = new Map;
+  const nodeSizes = new Map;
+  const topLevelContainerIds = [...childrenByParent.keys()].filter((id) => !containerChildIds.has(id));
+  for (const containerId of topLevelContainerIds) {
+    const { updates } = await tidyContainerHierarchy({
+      containerId,
+      childrenByParent: tidyChildrenByParent,
+      edgesByParent: elkEdgesByParent,
+      fit: defaultContainerFit(),
+      direction: "RIGHT",
+      nodeSpacing: DEFAULT_INTERIOR_NODE_SPACING,
+      layerSpacing: DEFAULT_INTERIOR_LAYER_SPACING,
+      orthogonalRouting: true,
+      snapUp: snapUpToGrid,
+      defaultNodeSize: COLLAPSED_NODE_SIZE,
+      layout: (root) => engine.layoutHierarchical(root)
+    });
+    for (const [id, upd] of updates) {
+      if (upd.position) {
+        childRelPositions.set(id, upd.position);
+      }
+      if (upd.width !== undefined && upd.height !== undefined) {
+        nodeSizes.set(id, { width: upd.width, height: upd.height });
+      }
+    }
+  }
   const artifactChildIds = identifyArtifactChildIds(allEdges, portResolver, allNodes);
   const collapsedIds = new Set(allNodes.filter((n) => n.data?.ui?.isCollapsed).map((n) => n.id));
   const hiddenIds = collectArtifactDescendants(collapsedIds, allEdges, artifactChildIds);
-  const layoutNodes = allNodes.filter((n) => !hiddenIds.has(n.id));
-  const layoutEdges = allEdges.filter((e) => !hiddenIds.has(e.source) && !hiddenIds.has(e.target));
+  const excludedIds = new Set([...hiddenIds, ...containerChildIds]);
+  const layoutNodes = allNodes.filter((n) => !excludedIds.has(n.id));
+  const layoutEdges = allEdges.filter((e) => !excludedIds.has(e.source) && !excludedIds.has(e.target));
   const hiddenNodes = allNodes.filter((n) => hiddenIds.has(n.id));
+  for (const n of layoutNodes) {
+    const grown = nodeSizes.get(n.id);
+    if (grown) {
+      n.width = grown.width;
+      n.height = grown.height;
+    }
+  }
   if (layoutNodes.length === 0) {
     return { repositioned: 0, resized: 0 };
   }
   const preLayoutPositions = new Map(layoutNodes.map((n) => [n.id, { ...n.position }]));
-  const leftmostNode = layoutNodes.reduce((left, node) => node.position.x < left.position.x ? node : left);
+  const anchorCandidates = layoutNodes.filter((node) => !UI_ONLY_NODE_TYPES.has(node.type ?? ""));
+  const anchorPool = anchorCandidates.length > 0 ? anchorCandidates : layoutNodes;
+  const leftmostNode = anchorPool.reduce((left, node) => node.position.x < left.position.x ? node : left, anchorPool[0]);
   const originalLeftX = leftmostNode.position.x;
   const originalLeftY = leftmostNode.position.y;
   const { nodes: layoutedNodes } = await engine.layout(layoutNodes, layoutEdges, { ...DEFAULT_LAYOUT_OPTIONS, animate: false }, portResolver);
@@ -678,7 +971,11 @@ async function tidyNodesAndEdges(engine, nodes, edges, portResolver, shapeOf) {
   }
   const hiddenUpdates = propagateHiddenArtifactPositions(layoutedNodes, preLayoutPositions, hiddenNodes, allEdges, artifactChildIds);
   const allUpdated = [...layoutedNodes, ...hiddenUpdates];
-  return applyLayoutToNodes(nodes, allUpdated, shapeOf);
+  const result = applyLayoutToNodes(nodes, allUpdated, shapeOf);
+  const nested = applyContainerLayout(nodes, childRelPositions, nodeSizes);
+  result.repositioned += nested.repositioned;
+  result.resized += nested.resized;
+  return result;
 }
 async function tidyFlow(filePath) {
   const { workflow, refMap } = await readFlowWorkflow(filePath);
@@ -754,4 +1051,4 @@ function regenerateNodeVariables(workflow) {
 
 export { UI_ONLY_NODE_TYPES, tidyFlow };
 
-//# debugId=61782660AAF1BE9364756E2164756E21
+//# debugId=DEA00C408BBCA7A764756E2164756E21