@uipath/apollo-react 4.16.0 → 4.17.0-pr605.1e1e7d4

package/dist/canvas/utils/container.d.ts

@@ -0,0 +1,97 @@
+import type { Edge, Node, ReactFlowInstance } from '../xyflow/react.ts';
+import type { NodeManifest } from '../schema/node-definition';
+import type { PreviewEndpoint, PreviewGraphOverrides } from './createPreviewGraph';
+export interface NodeDimensions {
+    width: number;
+    height: number;
+}
+export interface ContainerFitGeometry {
+    minWidth: number;
+    minHeight: number;
+    padding?: {
+        right?: number;
+        bottom?: number;
+    };
+}
+export interface ContainerSafeArea {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    padding?: {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+}
+export interface ContainerSizeChange {
+    containerId: string;
+    previousSize: NodeDimensions;
+    nextSize: NodeDimensions;
+}
+export interface EnsureContainersFitChildrenResult {
+    nodes: Node[];
+    changes: ContainerSizeChange[];
+}
+export interface ContainerPlacement {
+    containerId: string;
+    sourceNodeId?: string;
+    targetNodeId?: string;
+    mode: 'first-child' | 'sequence';
+}
+interface ContainerPreviewContext {
+    source: PreviewEndpoint;
+    sourceHandleType: 'source' | 'target';
+    reactFlowInstance: ReactFlowInstance;
+}
+interface ContainerPreviewOptions {
+    isContainerNode?: (node: Node) => boolean;
+    getContainerSafeArea?: (containerNode: Node) => ContainerSafeArea | undefined;
+    getContainerContinuationTarget?: (context: {
+        containerNode: Node;
+        sourceNode: Node;
+        source: PreviewEndpoint;
+        reactFlowInstance: ReactFlowInstance;
+    }) => PreviewEndpoint | null | undefined;
+    previewNodeSize?: NodeDimensions;
+    gap?: number;
+    avoidSiblings?: boolean;
+    getNodeDimensions?: (node: Node) => NodeDimensions;
+}
+export declare const DEFAULT_CONTAINER_WIDTH: number;
+export declare const DEFAULT_CONTAINER_HEIGHT: number;
+export declare const DEFAULT_CONTAINER_MIN_WIDTH: number;
+export declare const DEFAULT_CONTAINER_MIN_HEIGHT: number;
+export declare const CONTAINER_FRAME_INSET_PX = 10;
+export declare const CONTAINER_SEQUENCE_GAP_PX: number;
+export declare function getNodeDimensions(node: Pick<Node, 'width' | 'height' | 'measured' | 'style'>, fallback?: NodeDimensions): NodeDimensions;
+export declare function getContainerSafeArea(containerNode: Pick<Node, 'width' | 'height' | 'measured' | 'style'>, fallback?: NodeDimensions): ContainerSafeArea;
+export declare function getContainerFitGeometry(): ContainerFitGeometry;
+export declare function isContainerNodeManifest(manifest: Pick<NodeManifest, 'display'> | undefined): boolean;
+export declare function ensureContainersFitChildren(nodes: Node[], { containerIds, getContainerFitGeometry: resolveContainerFitGeometry, getNodeDimensions: resolveNodeDimensions, ignoredNodeTypes, includeAncestors, }?: {
+    containerIds?: Iterable<string>;
+    getContainerFitGeometry?: (containerNode: Node) => ContainerFitGeometry | null | undefined;
+    getNodeDimensions?: (node: Node) => NodeDimensions;
+    ignoredNodeTypes?: string[];
+    includeAncestors?: boolean;
+}): EnsureContainersFitChildrenResult;
+export declare function getContainerNodeForEdge(sourceNode: Node, targetNode: Node, nodes: Node[]): Node | null;
+export declare function resolveContainerPreview({ source, sourceHandleType, reactFlowInstance, ...options }: ContainerPreviewContext & ContainerPreviewOptions): PreviewGraphOverrides | null;
+export declare function getContainerPlacement({ previewNode, isContainerId, }: {
+    previewNode: Pick<Node, 'data' | 'parentId'>;
+    isContainerId?: (containerId: string) => boolean;
+}): ContainerPlacement | null;
+export declare function placeContainerNode({ nodes, insertedNode, placement, safeArea, getContainerFitGeometry: resolveContainerFitGeometry, getNodeDimensions: resolveNodeDimensions, gap, downstreamNodeIds, edges, }: {
+    nodes: Node[];
+    insertedNode: Node;
+    placement: ContainerPlacement;
+    safeArea?: ContainerSafeArea;
+    getContainerFitGeometry?: (containerNode: Node) => ContainerFitGeometry | null | undefined;
+    getNodeDimensions?: (node: Node) => NodeDimensions;
+    gap?: number;
+    downstreamNodeIds?: Iterable<string>;
+    edges?: Edge[];
+}): Node[];
+export {};
+//# sourceMappingURL=container.d.ts.map

package/dist/canvas/utils/container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../../src/canvas/utils/container.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,IAAI,EACJ,iBAAiB,EAElB,MAAM,0CAA0C,CAAC;AAOlD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAanF,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAOD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAMD,MAAM,WAAW,iBAAiB;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAGD,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,cAAc,CAAC;IAC7B,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAGD,MAAM,WAAW,iCAAiC;IAChD,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,OAAO,EAAE,mBAAmB,EAAE,CAAC;CAChC;AAMD,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,aAAa,GAAG,UAAU,CAAC;CAClC;AAOD,UAAU,uBAAuB;IAC/B,MAAM,EAAE,eAAe,CAAC;IACxB,gBAAgB,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACtC,iBAAiB,EAAE,iBAAiB,CAAC;CACtC;AAED,UAAU,uBAAuB;IAC/B,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC;IAC1C,oBAAoB,CAAC,EAAE,CAAC,aAAa,EAAE,IAAI,KAAK,iBAAiB,GAAG,SAAS,CAAC;IAC9E,8BAA8B,CAAC,EAAE,CAAC,OAAO,EAAE;QACzC,aAAa,EAAE,IAAI,CAAC;QACpB,UAAU,EAAE,IAAI,CAAC;QACjB,MAAM,EAAE,eAAe,CAAC;QACxB,iBAAiB,EAAE,iBAAiB,CAAC;KACtC,KAAK,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC;IACzC,eAAe,CAAC,EAAE,cAAc,CAAC;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,cAAc,CAAC;CACpD;AAcD,eAAO,MAAM,uBAAuB,QAAoB,CAAC;AACzD,eAAO,MAAM,wBAAwB,QAAoB,CAAC;AAG1D,eAAO,MAAM,2BAA2B,QAAoB,CAAC;AAC7D,eAAO,MAAM,4BAA4B,QAAoB,CAAC;AAG9D,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAQ3C,eAAO,MAAM,yBAAyB,QAAmB,CAAC;AAwB1D,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAC,EAC3D,QAAQ,GAAE,cAAwE,GACjF,cAAc,CAQhB;AAOD,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAC,EACpE,QAAQ,GAAE,cAAqF,GAC9F,iBAAiB,CAuBnB;AAGD,wBAAgB,uBAAuB,IAAI,oBAAoB,CAc9D;AAGD,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,GAAG,SAAS,GAClD,OAAO,CAET;AA4CD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,IAAI,EAAE,EACb,EACE,YAAY,EACZ,uBAAuB,EAAE,2BAA2B,EACpD,iBAAiB,EAAE,qBAAyC,EAC5D,gBAAqB,EACrB,gBAAuB,GACxB,GAAE;IACD,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChC,uBAAuB,CAAC,EAAE,CAAC,aAAa,EAAE,IAAI,KAAK,oBAAoB,GAAG,IAAI,GAAG,SAAS,CAAC;IAC3F,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,cAAc,CAAC;IACnD,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACvB,GACL,iCAAiC,CAsFnC;AAwJD,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,IAAI,EAChB,UAAU,EAAE,IAAI,EAChB,KAAK,EAAE,IAAI,EAAE,GACZ,IAAI,GAAG,IAAI,CAcb;AA2QD,wBAAgB,uBAAuB,CAAC,EACtC,MAAM,EACN,gBAAgB,EAChB,iBAAiB,EACjB,GAAG,OAAO,EACX,EAAE,uBAAuB,GAAG,uBAAuB,GAAG,qBAAqB,GAAG,IAAI,CAkBlF;AA+RD,wBAAgB,qBAAqB,CAAC,EACpC,WAAW,EACX,aAAa,GACd,EAAE;IACD,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC;IAC7C,aAAa,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;CAClD,GAAG,kBAAkB,GAAG,IAAI,CAW5B;AAOD,wBAAgB,kBAAkB,CAAC,EACjC,KAAK,EACL,YAAY,EACZ,SAAS,EACT,QAAQ,EACR,uBAAuB,EAAE,2BAAqD,EAC9E,iBAAiB,EAAE,qBAAyC,EAC5D,GAA+B,EAC/B,iBAAiB,EACjB,KAAK,GACN,EAAE;IACD,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,YAAY,EAAE,IAAI,CAAC;IACnB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,uBAAuB,CAAC,EAAE,CAAC,aAAa,EAAE,IAAI,KAAK,oBAAoB,GAAG,IAAI,GAAG,SAAS,CAAC;IAC3F,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,cAAc,CAAC;IACnD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,iBAAiB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;CAChB,GAAG,IAAI,EAAE,CAwET"}

package/dist/canvas/utils/container.js

@@ -0,0 +1,567 @@
+import { DEFAULT_NODE_SIZE, DEFAULT_SOURCE_HANDLE_ID, GRID_SPACING, PREVIEW_NODE_ID } from "../constants.js";
+import { clamp, getAbsolutePosition, getNonOverlappingPositionForDirection, snapToGrid, snapUpToGrid } from "./NodeUtils.js";
+const DEFAULT_CONTAINER_WIDTH = 35 * GRID_SPACING;
+const DEFAULT_CONTAINER_HEIGHT = 20 * GRID_SPACING;
+const DEFAULT_CONTAINER_MIN_WIDTH = 25 * GRID_SPACING;
+const DEFAULT_CONTAINER_MIN_HEIGHT = 14 * GRID_SPACING;
+const CONTAINER_FRAME_INSET_PX = 10;
+const CONTAINER_BODY_PADDING_PX = 2 * GRID_SPACING;
+const CONTAINER_INNER_HANDLE_RAIL_WIDTH_PX = 5 * GRID_SPACING;
+const CONTAINER_CHILD_SAFE_GAP_PX = GRID_SPACING;
+const DEFAULT_CONTAINER_HEADER_HEIGHT_PX = 40;
+const CONTAINER_SEQUENCE_GAP_PX = 3 * GRID_SPACING;
+const PLACEMENT_DATA_KEY = 'placement';
+function readNumericDimension(...values) {
+    for (const value of values){
+        if ('number' == typeof value && Number.isFinite(value)) return value;
+        if ('string' == typeof value) {
+            const parsedValue = Number.parseFloat(value);
+            if (Number.isFinite(parsedValue)) return parsedValue;
+        }
+    }
+}
+function container_getNodeDimensions(node, fallback = {
+    width: DEFAULT_NODE_SIZE,
+    height: DEFAULT_NODE_SIZE
+}) {
+    return {
+        width: readNumericDimension(node.width, node.measured?.width, node.style?.width) ?? fallback.width,
+        height: readNumericDimension(node.height, node.measured?.height, node.style?.height) ?? fallback.height
+    };
+}
+function container_getContainerSafeArea(containerNode, fallback = {
+    width: DEFAULT_CONTAINER_WIDTH,
+    height: DEFAULT_CONTAINER_HEIGHT
+}) {
+    const size = container_getNodeDimensions(containerNode, fallback);
+    const horizontalPadding = snapUpToGrid(CONTAINER_FRAME_INSET_PX + CONTAINER_BODY_PADDING_PX + CONTAINER_INNER_HANDLE_RAIL_WIDTH_PX + CONTAINER_CHILD_SAFE_GAP_PX);
+    const verticalPadding = snapUpToGrid(CONTAINER_FRAME_INSET_PX + CONTAINER_BODY_PADDING_PX);
+    const padding = {
+        left: horizontalPadding,
+        right: horizontalPadding,
+        top: snapUpToGrid(DEFAULT_CONTAINER_HEADER_HEIGHT_PX + verticalPadding),
+        bottom: verticalPadding
+    };
+    return {
+        x: padding.left,
+        y: padding.top,
+        width: Math.max(0, size.width - padding.left - padding.right),
+        height: Math.max(0, size.height - padding.top - padding.bottom),
+        padding
+    };
+}
+function container_getContainerFitGeometry() {
+    const padding = container_getContainerSafeArea({
+        width: DEFAULT_CONTAINER_WIDTH,
+        height: DEFAULT_CONTAINER_HEIGHT
+    }).padding;
+    return {
+        minWidth: DEFAULT_CONTAINER_MIN_WIDTH,
+        minHeight: DEFAULT_CONTAINER_MIN_HEIGHT,
+        padding: {
+            right: padding.right,
+            bottom: padding.bottom
+        }
+    };
+}
+function isContainerNodeManifest(manifest) {
+    return manifest?.display.shape === 'container';
+}
+function getAncestorContainerIds(containerId, nodesById) {
+    const ancestors = [];
+    let parentId = nodesById.get(containerId)?.parentId;
+    while(parentId){
+        ancestors.push(parentId);
+        parentId = nodesById.get(parentId)?.parentId;
+    }
+    return ancestors;
+}
+function getContainerDepth(containerId, nodesById) {
+    let depth = 0;
+    let parentId = nodesById.get(containerId)?.parentId;
+    while(parentId){
+        depth += 1;
+        parentId = nodesById.get(parentId)?.parentId;
+    }
+    return depth;
+}
+function withNodeDimensions(node, size) {
+    return {
+        ...node,
+        width: size.width,
+        height: size.height,
+        style: {
+            ...node.style,
+            width: size.width,
+            height: size.height
+        }
+    };
+}
+function ensureContainersFitChildren(nodes, { containerIds, getContainerFitGeometry: resolveContainerFitGeometry, getNodeDimensions: resolveNodeDimensions = container_getNodeDimensions, ignoredNodeTypes = [], includeAncestors = true } = {}) {
+    let nextNodes = nodes;
+    const changes = [];
+    const ignoredTypes = new Set(ignoredNodeTypes);
+    const nodesById = new Map(nextNodes.map((node)=>[
+            node.id,
+            node
+        ]));
+    const idsToFit = new Set();
+    if (containerIds) for (const id of containerIds)idsToFit.add(id);
+    else for (const node of nextNodes)if (node.parentId) idsToFit.add(node.parentId);
+    if (includeAncestors) for (const id of Array.from(idsToFit))for (const ancestorId of getAncestorContainerIds(id, nodesById))idsToFit.add(ancestorId);
+    const orderedContainerIds = Array.from(idsToFit).sort((left, right)=>getContainerDepth(right, nodesById) - getContainerDepth(left, nodesById));
+    for (const containerId of orderedContainerIds){
+        const containerNode = nextNodes.find((node)=>node.id === containerId);
+        if (!containerNode) continue;
+        const geometry = resolveContainerFitGeometry?.(containerNode);
+        if (!geometry) continue;
+        const currentSize = resolveNodeDimensions(containerNode);
+        const padding = geometry.padding ?? {};
+        let requiredWidth = geometry.minWidth;
+        let requiredHeight = geometry.minHeight;
+        for (const childNode of nextNodes){
+            if (childNode.id === PREVIEW_NODE_ID || childNode.hidden || childNode.parentId !== containerId || ignoredTypes.has(childNode.type ?? '')) continue;
+            const childSize = resolveNodeDimensions(childNode);
+            requiredWidth = Math.max(requiredWidth, childNode.position.x + childSize.width + (padding.right ?? 0));
+            requiredHeight = Math.max(requiredHeight, childNode.position.y + childSize.height + (padding.bottom ?? 0));
+        }
+        const nextSize = {
+            width: Math.max(currentSize.width, snapUpToGrid(requiredWidth)),
+            height: Math.max(currentSize.height, snapUpToGrid(requiredHeight))
+        };
+        if (nextSize.width !== currentSize.width || nextSize.height !== currentSize.height) {
+            nextNodes = nextNodes.map((node)=>node.id === containerId ? withNodeDimensions(node, nextSize) : node);
+            nodesById.set(containerId, nextNodes.find((node)=>node.id === containerId));
+            changes.push({
+                containerId,
+                previousSize: currentSize,
+                nextSize
+            });
+        }
+    }
+    return {
+        nodes: nextNodes,
+        changes
+    };
+}
+function getSafeArea(containerNode, safeArea) {
+    return safeArea ?? container_getContainerSafeArea(containerNode);
+}
+function clampTopLeftToSafeArea(position, safeArea, nodeSize) {
+    const maxX = safeArea.x + Math.max(0, safeArea.width - nodeSize.width);
+    const maxY = safeArea.y + Math.max(0, safeArea.height - nodeSize.height);
+    return {
+        x: clamp(position.x, safeArea.x, maxX),
+        y: clamp(position.y, safeArea.y, maxY)
+    };
+}
+function clampTopToSafeArea(top, safeArea, nodeSize) {
+    const maxY = safeArea.y + Math.max(0, safeArea.height - nodeSize.height);
+    return clamp(top, safeArea.y, maxY);
+}
+function rangesOverlap(startA, endA, startB, endB) {
+    return startA < endB && endA > startB;
+}
+function centerInSafeArea(safeArea, nodeSize) {
+    return {
+        x: Math.max(safeArea.x, snapToGrid(safeArea.x + (safeArea.width - nodeSize.width) / 2)),
+        y: Math.max(safeArea.y, snapToGrid(safeArea.y + (safeArea.height - nodeSize.height) / 2))
+    };
+}
+function getLocalNodePosition(node, containerNode, nodes) {
+    if (!node || node.id === containerNode.id) return null;
+    if (node.parentId === containerNode.id) return node.position;
+    const containerPosition = getAbsolutePosition(containerNode, nodes);
+    const nodePosition = node.parentId ? getAbsolutePosition(node, nodes) : node.position;
+    return {
+        x: nodePosition.x - containerPosition.x,
+        y: nodePosition.y - containerPosition.y
+    };
+}
+function getPlacementDirection(sourcePosition, targetPosition) {
+    if (!sourcePosition || !targetPosition) return sourcePosition ? 'right' : 'left';
+    return targetPosition.x >= sourcePosition.x ? 'right' : 'left';
+}
+function getSiblingNodes(containerId, nodes, insertedNodeId) {
+    return nodes.filter((node)=>node.id !== PREVIEW_NODE_ID && node.id !== insertedNodeId && node.parentId === containerId);
+}
+function resolveSequenceTopLeft({ sourceNode, targetNode, containerNode, nodes, safeArea, previewNodeSize, gap, getNodeDimensions }) {
+    const sourcePosition = getLocalNodePosition(sourceNode, containerNode, nodes);
+    const targetPosition = getLocalNodePosition(targetNode, containerNode, nodes);
+    const sourceSize = sourceNode ? getNodeDimensions(sourceNode) : void 0;
+    const targetSize = targetNode ? getNodeDimensions(targetNode) : void 0;
+    if (sourcePosition && sourceSize && targetPosition) {
+        const sourceRight = sourcePosition.x + sourceSize.width;
+        const targetLeft = targetPosition.x;
+        const centerX = targetLeft - sourceRight >= previewNodeSize.width + 2 * gap ? sourceRight + (targetLeft - sourceRight) / 2 : sourceRight + gap + previewNodeSize.width / 2;
+        return {
+            x: centerX - previewNodeSize.width / 2,
+            y: sourcePosition.y + sourceSize.height / 2 - previewNodeSize.height / 2
+        };
+    }
+    if (sourcePosition && sourceSize) return {
+        x: sourcePosition.x + sourceSize.width + gap,
+        y: sourcePosition.y + sourceSize.height / 2 - previewNodeSize.height / 2
+    };
+    if (targetPosition && targetSize) return {
+        x: targetPosition.x - previewNodeSize.width - gap,
+        y: targetPosition.y + targetSize.height / 2 - previewNodeSize.height / 2
+    };
+    return {
+        x: safeArea.x + safeArea.width / 2 - previewNodeSize.width / 2,
+        y: safeArea.y + safeArea.height / 2 - previewNodeSize.height / 2
+    };
+}
+function getContainerNodeForEdge(sourceNode, targetNode, nodes) {
+    if (sourceNode.parentId === targetNode.id) return targetNode;
+    if (targetNode.parentId === sourceNode.id) return sourceNode;
+    if (sourceNode.parentId && sourceNode.parentId === targetNode.parentId) return nodes.find((node)=>node.id === sourceNode.parentId) ?? null;
+    return null;
+}
+function handleMatches(edgeHandleId, handleId) {
+    return (edgeHandleId ?? DEFAULT_SOURCE_HANDLE_ID) === handleId;
+}
+function getOutgoingEdges(sourceNodeId, sourceHandleId, edges) {
+    return edges.filter((edge)=>edge.source !== PREVIEW_NODE_ID && edge.target !== PREVIEW_NODE_ID && edge.source === sourceNodeId && handleMatches(edge.sourceHandle, sourceHandleId));
+}
+function getSingleOutgoingEdge(sourceNodeId, sourceHandleId, edges) {
+    const outgoingEdges = getOutgoingEdges(sourceNodeId, sourceHandleId, edges);
+    return 1 === outgoingEdges.length ? outgoingEdges[0] : null;
+}
+function isPreviewGraphEdge(edge) {
+    return edge.source === PREVIEW_NODE_ID || edge.target === PREVIEW_NODE_ID;
+}
+function getDefaultNextContainerSequenceNodeId({ nodeId, edges, nodesById, containerId, isSequenceEdge }) {
+    const localOutgoingEdges = edges.filter((edge)=>{
+        if (isPreviewGraphEdge(edge) || edge.source !== nodeId) return false;
+        if (isSequenceEdge && !isSequenceEdge(edge)) return false;
+        const targetNode = nodesById.get(edge.target);
+        return edge.target === containerId || targetNode?.parentId === containerId;
+    });
+    return 1 === localOutgoingEdges.length ? localOutgoingEdges[0].target : null;
+}
+function collectDownstreamNodes({ targetNodeId, containerId, nodes, edges, isSequenceEdge, getNextNodeId }) {
+    if (!targetNodeId || targetNodeId === containerId) return [];
+    const nodesById = new Map(nodes.map((node)=>[
+            node.id,
+            node
+        ]));
+    const collectedIds = [];
+    const visitedIds = new Set();
+    let currentNodeId = targetNodeId;
+    while(!visitedIds.has(currentNodeId)){
+        const currentNode = nodesById.get(currentNodeId);
+        if (!currentNode || currentNode.parentId !== containerId) break;
+        collectedIds.push(currentNodeId);
+        visitedIds.add(currentNodeId);
+        const nextNodeId = getNextNodeId?.({
+            nodeId: currentNodeId,
+            edges,
+            nodesById,
+            containerId
+        }) ?? getDefaultNextContainerSequenceNodeId({
+            nodeId: currentNodeId,
+            edges,
+            nodesById,
+            containerId,
+            isSequenceEdge
+        });
+        if (!nextNodeId || nextNodeId === containerId) break;
+        currentNodeId = nextNodeId;
+    }
+    return collectedIds;
+}
+function resolveInsertPreview({ source, sourceHandleType, reactFlowInstance, isContainerNode, getContainerSafeArea, previewNodeSize, gap, getNodeDimensions }) {
+    if ('source' !== sourceHandleType || !source.handleId) return null;
+    const replacedEdge = getSingleOutgoingEdge(source.nodeId, source.handleId, reactFlowInstance.getEdges());
+    if (!replacedEdge) return null;
+    const sourceNode = reactFlowInstance.getNode(replacedEdge.source);
+    const targetNode = reactFlowInstance.getNode(replacedEdge.target);
+    const nodes = reactFlowInstance.getNodes();
+    const containerNode = getContainerNodeForEdge(sourceNode, targetNode, nodes);
+    if (!containerNode) return null;
+    if (isContainerNode && !isContainerNode(containerNode)) return null;
+    const containerPlacement = getPreviewPlacement({
+        sourceNode,
+        targetNode,
+        containerNode,
+        nodes,
+        safeArea: getContainerSafeArea?.(containerNode),
+        previewNodeSize,
+        gap,
+        getNodeDimensions
+    });
+    const placement = {
+        containerId: containerPlacement.containerId,
+        sourceNodeId: sourceNode.id,
+        targetNodeId: targetNode.id,
+        mode: 'sequence'
+    };
+    return {
+        position: containerPlacement.centerPosition,
+        positionMode: 'center',
+        data: {
+            originalEdge: replacedEdge,
+            [PLACEMENT_DATA_KEY]: placement
+        },
+        target: {
+            nodeId: replacedEdge.target,
+            handleId: replacedEdge.targetHandle
+        },
+        containerId: containerPlacement.containerId
+    };
+}
+function resolveAppendPreview({ source, sourceHandleType, reactFlowInstance, ...options }) {
+    if ('source' !== sourceHandleType || !source.handleId) return null;
+    const sourceNode = reactFlowInstance.getNode(source.nodeId);
+    if (!sourceNode?.parentId) return null;
+    const outgoingEdges = getOutgoingEdges(source.nodeId, source.handleId, reactFlowInstance.getEdges());
+    if (outgoingEdges.length > 0) return null;
+    const nodes = reactFlowInstance.getNodes();
+    const containerNode = nodes.find((node)=>node.id === sourceNode.parentId);
+    if (options.isContainerNode && !options.isContainerNode(containerNode)) return null;
+    const continuationTarget = options.getContainerContinuationTarget?.({
+        containerNode,
+        sourceNode,
+        source,
+        reactFlowInstance
+    });
+    if (!continuationTarget) return null;
+    const targetNode = continuationTarget.nodeId === containerNode.id ? containerNode : reactFlowInstance.getNode(continuationTarget.nodeId);
+    const containerPlacement = getPreviewPlacement({
+        sourceNode,
+        targetNode,
+        containerNode,
+        nodes,
+        safeArea: options.getContainerSafeArea?.(containerNode),
+        previewNodeSize: options.previewNodeSize,
+        gap: options.gap,
+        avoidSiblings: options.avoidSiblings ?? true,
+        getNodeDimensions: options.getNodeDimensions
+    });
+    const placement = {
+        containerId: containerPlacement.containerId,
+        sourceNodeId: sourceNode.id,
+        targetNodeId: continuationTarget.nodeId,
+        mode: 'sequence'
+    };
+    return {
+        position: containerPlacement.centerPosition,
+        positionMode: 'center',
+        data: {
+            [PLACEMENT_DATA_KEY]: placement
+        },
+        target: continuationTarget,
+        containerId: containerPlacement.containerId
+    };
+}
+function resolveContainerPreview({ source, sourceHandleType, reactFlowInstance, ...options }) {
+    return resolveInsertPreview({
+        source,
+        sourceHandleType,
+        reactFlowInstance,
+        ...options
+    }) ?? resolveAppendPreview({
+        source,
+        sourceHandleType,
+        reactFlowInstance,
+        ...options
+    });
+}
+function getPreviewPlacement({ sourceNode, targetNode, containerNode, nodes, containerAbsolutePosition = getAbsolutePosition(containerNode, nodes), safeArea, previewNodeSize = {
+    width: DEFAULT_NODE_SIZE,
+    height: DEFAULT_NODE_SIZE
+}, gap = CONTAINER_SEQUENCE_GAP_PX, avoidSiblings = false, getNodeDimensions: resolveNodeDimensions = container_getNodeDimensions }) {
+    const resolvedSafeArea = getSafeArea(containerNode, safeArea);
+    const sourcePosition = getLocalNodePosition(sourceNode, containerNode, nodes);
+    const targetPosition = getLocalNodePosition(targetNode, containerNode, nodes);
+    const direction = getPlacementDirection(sourcePosition, targetPosition);
+    const initialPosition = resolveSequenceTopLeft({
+        sourceNode,
+        targetNode,
+        containerNode,
+        nodes,
+        safeArea: resolvedSafeArea,
+        previewNodeSize,
+        gap,
+        getNodeDimensions: resolveNodeDimensions
+    });
+    const collisionPosition = avoidSiblings ? getNonOverlappingPositionForDirection(getSiblingNodes(containerNode.id, nodes), initialPosition, previewNodeSize, direction, gap) : initialPosition;
+    const position = clampTopLeftToSafeArea(collisionPosition, resolvedSafeArea, previewNodeSize);
+    return {
+        containerId: containerNode.id,
+        centerPosition: {
+            x: containerAbsolutePosition.x + position.x + previewNodeSize.width / 2,
+            y: containerAbsolutePosition.y + position.y + previewNodeSize.height / 2
+        }
+    };
+}
+function getNodeCenterY(position, nodeSize) {
+    return position.y + nodeSize.height / 2;
+}
+function getInsertedPosition({ sourceNode, targetNode, insertedNode, containerNode, nodes, safeArea, insertedNodeSize, gap, getNodeDimensions }) {
+    const sourcePosition = getLocalNodePosition(sourceNode, containerNode, nodes);
+    const targetPosition = getLocalNodePosition(targetNode, containerNode, nodes);
+    const sourceSize = sourceNode ? getNodeDimensions(sourceNode) : void 0;
+    const targetSize = targetNode ? getNodeDimensions(targetNode) : void 0;
+    const sourceIsContainer = sourceNode?.id === containerNode.id;
+    const targetIsContainer = targetNode?.id === containerNode.id;
+    if (sourcePosition && sourceSize && !sourceIsContainer) return {
+        x: Math.max(safeArea.x, snapToGrid(sourcePosition.x + sourceSize.width + gap)),
+        y: clampTopToSafeArea(snapToGrid(getNodeCenterY(sourcePosition, sourceSize) - insertedNodeSize.height / 2), safeArea, insertedNodeSize)
+    };
+    if (targetPosition && targetSize && !targetIsContainer) return {
+        x: Math.max(safeArea.x, snapToGrid(targetPosition.x - insertedNodeSize.width - gap)),
+        y: clampTopToSafeArea(snapToGrid(getNodeCenterY(targetPosition, targetSize) - insertedNodeSize.height / 2), safeArea, insertedNodeSize)
+    };
+    return {
+        x: Math.max(safeArea.x, snapToGrid(insertedNode.position.x)),
+        y: clampTopToSafeArea(snapToGrid(insertedNode.position.y), safeArea, insertedNodeSize)
+    };
+}
+function getNodeDepth(node, nodesById) {
+    let depth = 0;
+    let parentId = node?.parentId;
+    while(parentId){
+        depth += 1;
+        parentId = nodesById.get(parentId)?.parentId;
+    }
+    return depth;
+}
+function sortContainerSizeChanges(changes, nodes) {
+    const nodesById = new Map(nodes.map((node)=>[
+            node.id,
+            node
+        ]));
+    return [
+        ...changes
+    ].sort((left, right)=>{
+        const leftNode = nodesById.get(left.containerId);
+        const rightNode = nodesById.get(right.containerId);
+        const depthDifference = getNodeDepth(rightNode, nodesById) - getNodeDepth(leftNode, nodesById);
+        if (0 !== depthDifference) return depthDifference;
+        if (leftNode.parentId === rightNode.parentId) return leftNode.position.x - rightNode.position.x;
+        return 0;
+    });
+}
+function pushSiblingsAfterContainerGrowth({ nodes, changes, getNodeDimensions, gap }) {
+    let shifted = false;
+    let nextNodes = nodes;
+    for (const change of sortContainerSizeChanges(changes, nextNodes)){
+        const widthDelta = change.nextSize.width - change.previousSize.width;
+        if (widthDelta <= 0) continue;
+        const containerNode = nextNodes.find((node)=>node.id === change.containerId);
+        const oldRight = containerNode.position.x + change.previousSize.width;
+        const newRight = containerNode.position.x + change.nextSize.width;
+        const containerTop = containerNode.position.y;
+        const containerBottom = containerNode.position.y + Math.max(change.previousSize.height, change.nextSize.height);
+        nextNodes = nextNodes.map((node)=>{
+            if (node.id === containerNode.id || node.parentId !== containerNode.parentId) return node;
+            const nodeSize = getNodeDimensions(node);
+            const isRightSibling = node.position.x >= oldRight;
+            const verticallyOverlaps = rangesOverlap(node.position.y, node.position.y + nodeSize.height, containerTop, containerBottom);
+            if (!isRightSibling || !verticallyOverlaps) return node;
+            const nextX = Math.max(node.position.x + widthDelta, snapUpToGrid(newRight + gap));
+            if (nextX === node.position.x) return node;
+            shifted = true;
+            return {
+                ...node,
+                position: {
+                    ...node.position,
+                    x: nextX
+                }
+            };
+        });
+    }
+    return {
+        nodes: nextNodes,
+        shifted
+    };
+}
+function fitContainersAndPushSiblings({ nodes, containerIds, getContainerFitGeometry, getNodeDimensions, gap }) {
+    let nextNodes = nodes;
+    for(let iteration = 0; iteration < 10; iteration += 1){
+        const fitResult = ensureContainersFitChildren(nextNodes, {
+            containerIds,
+            getContainerFitGeometry,
+            getNodeDimensions,
+            includeAncestors: true
+        });
+        nextNodes = fitResult.nodes;
+        if (0 === fitResult.changes.length) break;
+        const pushResult = pushSiblingsAfterContainerGrowth({
+            nodes: nextNodes,
+            changes: fitResult.changes,
+            getNodeDimensions,
+            gap
+        });
+        nextNodes = pushResult.nodes;
+        if (!pushResult.shifted) break;
+    }
+    return nextNodes;
+}
+function getContainerPlacement({ previewNode, isContainerId }) {
+    const placement = previewNode.data?.[PLACEMENT_DATA_KEY];
+    if (!placement) return null;
+    if (previewNode.parentId && placement.containerId !== previewNode.parentId) return null;
+    return isContainerId && !isContainerId(placement.containerId) ? null : placement;
+}
+function placeContainerNode({ nodes, insertedNode, placement, safeArea, getContainerFitGeometry: resolveContainerFitGeometry = container_getContainerFitGeometry, getNodeDimensions: resolveNodeDimensions = container_getNodeDimensions, gap = CONTAINER_SEQUENCE_GAP_PX, downstreamNodeIds, edges }) {
+    const containerNode = nodes.find((node)=>node.id === placement.containerId);
+    const nodesById = new Map(nodes.map((node)=>[
+            node.id,
+            node
+        ]));
+    const insertedSize = resolveNodeDimensions(insertedNode);
+    const resolvedSafeArea = getSafeArea(containerNode, safeArea);
+    const positionedNode = 'first-child' === placement.mode ? {
+        ...insertedNode,
+        position: centerInSafeArea(resolvedSafeArea, insertedSize)
+    } : {
+        ...insertedNode,
+        position: getInsertedPosition({
+            sourceNode: placement.sourceNodeId ? nodesById.get(placement.sourceNodeId) : void 0,
+            targetNode: placement.targetNodeId ? nodesById.get(placement.targetNodeId) : void 0,
+            insertedNode,
+            containerNode,
+            nodes,
+            safeArea: resolvedSafeArea,
+            insertedNodeSize: insertedSize,
+            gap,
+            getNodeDimensions: resolveNodeDimensions
+        })
+    };
+    const targetNode = placement.targetNodeId && placement.targetNodeId !== placement.containerId ? nodesById.get(placement.targetNodeId) : void 0;
+    const fallbackTargetIds = placement.targetNodeId && placement.targetNodeId !== placement.containerId ? [
+        placement.targetNodeId
+    ] : [];
+    const idsToShift = new Set(downstreamNodeIds ?? (edges ? collectDownstreamNodes({
+        targetNodeId: placement.targetNodeId,
+        containerId: placement.containerId,
+        nodes,
+        edges
+    }) : fallbackTargetIds));
+    const requiredTargetLeft = positionedNode.position.x + insertedSize.width + gap;
+    const downstreamShift = targetNode && targetNode.position.x < requiredTargetLeft ? snapUpToGrid(requiredTargetLeft - targetNode.position.x) : 0;
+    const positionedNodes = nodes.map((node)=>{
+        if (node.id === insertedNode.id) return positionedNode;
+        if (downstreamShift > 0 && idsToShift.has(node.id)) return {
+            ...node,
+            position: {
+                ...node.position,
+                x: node.position.x + downstreamShift
+            }
+        };
+        return node;
+    });
+    return fitContainersAndPushSiblings({
+        nodes: positionedNodes,
+        containerIds: [
+            placement.containerId
+        ],
+        getContainerFitGeometry: resolveContainerFitGeometry,
+        getNodeDimensions: resolveNodeDimensions,
+        gap
+    });
+}
+export { CONTAINER_FRAME_INSET_PX, CONTAINER_SEQUENCE_GAP_PX, DEFAULT_CONTAINER_HEIGHT, DEFAULT_CONTAINER_MIN_HEIGHT, DEFAULT_CONTAINER_MIN_WIDTH, DEFAULT_CONTAINER_WIDTH, ensureContainersFitChildren, container_getContainerFitGeometry as getContainerFitGeometry, getContainerNodeForEdge, getContainerPlacement, container_getContainerSafeArea as getContainerSafeArea, container_getNodeDimensions as getNodeDimensions, isContainerNodeManifest, placeContainerNode, resolveContainerPreview };