@uipath/apollo-react 4.14.1 → 4.15.0-pr605.6ea14a7

package/dist/canvas/components/LoopNode/LoopNode.sequence.js

@@ -0,0 +1,343 @@
+import { DEFAULT_NODE_SIZE, DEFAULT_SOURCE_HANDLE_ID, GRID_SPACING } from "../../constants.js";
+import { getNodeDimensions } from "../../utils/container-sizing.js";
+import { isPreviewEdge } from "../../utils/createPreviewNode.js";
+import { clamp, getAbsolutePosition, snapToGrid, snapUpToGrid } from "../../utils/NodeUtils.js";
+import { getLoopChildSafeArea, getVisibleInnerHandleGroups, pickPreferredInnerHandle } from "./LoopNode.helpers.js";
+const LOOP_SEQUENCE_GAP_PX = 3 * GRID_SPACING;
+function LoopNode_sequence_getNodeSize(node, fallback) {
+    return node ? getNodeDimensions(node, fallback) : fallback;
+}
+function getNodeCenterY(node, nodeSize) {
+    return node.position.y + nodeSize.height / 2;
+}
+function getContainerNode({ sourceNode, targetNode }) {
+    if (targetNode && sourceNode.id === targetNode.id) return {
+        containerId: sourceNode.id,
+        mode: 'first-child'
+    };
+    const sourceParentId = sourceNode.parentId;
+    const targetParentId = targetNode?.parentId;
+    if (sourceParentId && (!targetNode || targetNode.id === sourceParentId || targetParentId === sourceParentId)) return {
+        containerId: sourceParentId,
+        mode: 'sequence'
+    };
+    if (targetParentId === sourceNode.id) return {
+        containerId: sourceNode.id,
+        mode: 'sequence'
+    };
+    return null;
+}
+function matchesSourceHandle(edge, sourceNodeId, sourceHandleId) {
+    return edge.source === sourceNodeId && (edge.sourceHandle ?? DEFAULT_SOURCE_HANDLE_ID) === sourceHandleId;
+}
+function isLoopLocalTarget(sourceNode, targetNode) {
+    if (!targetNode) return false;
+    if (sourceNode.parentId) return targetNode.parentId === sourceNode.parentId || targetNode.id === sourceNode.parentId;
+    return targetNode.parentId === sourceNode.id;
+}
+function resolvePreferredLoopContinuationTargetHandle(containerId, reactFlowInstance) {
+    const nodesById = new Map(reactFlowInstance.getNodes().map((node)=>[
+            node.id,
+            node
+        ]));
+    const containerNode = nodesById.get(containerId);
+    if (!containerNode) return null;
+    const handleConfiguration = containerNode.data?.handleConfigurations;
+    const configuredHandleId = Array.isArray(handleConfiguration) ? pickPreferredInnerHandle(getVisibleInnerHandleGroups(handleConfiguration, {
+        ...containerNode.data ?? {},
+        nodeId: containerNode.id
+    }), 'target')?.handle.id : null;
+    const returningEdges = reactFlowInstance.getEdges().filter((edge)=>!isPreviewEdge(edge) && edge.target === containerId).filter((edge)=>nodesById.get(edge.source)?.parentId === containerId);
+    if (configuredHandleId && (0 === returningEdges.length || returningEdges.some((edge)=>edge.targetHandle === configuredHandleId))) return {
+        targetHandleId: configuredHandleId
+    };
+    if (0 === returningEdges.length) return null;
+    const [firstReturningEdge] = returningEdges;
+    const targetHandleId = firstReturningEdge?.targetHandle ?? null;
+    return returningEdges.every((edge)=>(edge.targetHandle ?? null) === targetHandleId) ? {
+        targetHandleId
+    } : null;
+}
+function resolveLoopContinuationTarget({ sourceNodeId, sourceHandleId, reactFlowInstance }) {
+    const sourceNode = reactFlowInstance.getNode(sourceNodeId);
+    if (!sourceNode) return null;
+    const outgoingEdges = reactFlowInstance.getEdges().filter((edge)=>!isPreviewEdge(edge) && matchesSourceHandle(edge, sourceNodeId, sourceHandleId));
+    const loopLocalOutgoingEdges = outgoingEdges.filter((edge)=>isLoopLocalTarget(sourceNode, reactFlowInstance.getNode(edge.target)));
+    if (1 === outgoingEdges.length && 1 === loopLocalOutgoingEdges.length) {
+        const edge = loopLocalOutgoingEdges[0];
+        return {
+            type: 'target',
+            targetNodeId: edge.target,
+            targetHandleId: edge.targetHandle,
+            removedEdge: edge
+        };
+    }
+    if (loopLocalOutgoingEdges.length > 1) return {
+        type: 'ambiguous'
+    };
+    if (!sourceNode.parentId || outgoingEdges.length > 0) return null;
+    const targetHandle = resolvePreferredLoopContinuationTargetHandle(sourceNode.parentId, reactFlowInstance);
+    if (!targetHandle) return {
+        type: 'ambiguous'
+    };
+    return {
+        type: 'target',
+        targetNodeId: sourceNode.parentId,
+        targetHandleId: targetHandle.targetHandleId
+    };
+}
+function clampTopToSafeArea(top, nodeHeight, safeArea) {
+    if (safeArea.height <= nodeHeight) return safeArea.y;
+    return clamp(top, safeArea.y, safeArea.y + safeArea.height - nodeHeight);
+}
+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 overlaps(position, nodeSize, node, nodeFallbackSize) {
+    const existingSize = LoopNode_sequence_getNodeSize(node, nodeFallbackSize);
+    return node.position.x < position.x + nodeSize.width && node.position.x + existingSize.width > position.x && node.position.y < position.y + nodeSize.height && node.position.y + existingSize.height > position.y;
+}
+function avoidSiblingOverlap({ position, nodeSize, containerId, nodes, ignoredNodeIds, safeArea }) {
+    const siblings = nodes.filter((node)=>node.parentId === containerId && !ignoredNodeIds.has(node.id));
+    if (0 === siblings.length) return position;
+    const step = nodeSize.height + LOOP_SEQUENCE_GAP_PX;
+    const minY = safeArea.y;
+    const maxY = Math.max(safeArea.y, safeArea.y + safeArea.height - nodeSize.height);
+    const collides = (candidate)=>siblings.some((sibling)=>overlaps(candidate, nodeSize, sibling, nodeSize));
+    if (!collides(position)) return position;
+    for(let index = 1; index <= siblings.length + 1; index++){
+        const down = {
+            ...position,
+            y: Math.min(maxY, position.y + step * index)
+        };
+        if (!collides(down)) return down;
+        const up = {
+            ...position,
+            y: Math.max(minY, position.y - step * index)
+        };
+        if (!collides(up)) return up;
+    }
+    return position;
+}
+function getSequencePreviewTopLeft({ containerNode, sourceNode, targetNode, nodes, previewNodeSize, mode, avoidSiblings }) {
+    const safeArea = getLoopChildSafeArea(containerNode);
+    if ('first-child' === mode) return centerInSafeArea(safeArea, previewNodeSize);
+    const sourceSize = LoopNode_sequence_getNodeSize(sourceNode, previewNodeSize);
+    const targetSize = LoopNode_sequence_getNodeSize(targetNode, previewNodeSize);
+    const sourceIsContainer = sourceNode.id === containerNode.id;
+    const targetIsContainer = targetNode?.id === containerNode.id;
+    const sourceRight = sourceNode.position.x + sourceSize.width;
+    const targetLeft = targetNode?.position.x;
+    let x;
+    let centerY;
+    if (sourceIsContainer && targetNode && !targetIsContainer) {
+        x = Math.max(safeArea.x, targetNode.position.x - previewNodeSize.width - LOOP_SEQUENCE_GAP_PX);
+        centerY = getNodeCenterY(targetNode, targetSize);
+    } else {
+        const preferredAfterSourceX = sourceRight + LOOP_SEQUENCE_GAP_PX;
+        const canFitBetween = targetNode && !targetIsContainer && void 0 !== targetLeft && targetLeft - sourceRight >= previewNodeSize.width + 2 * LOOP_SEQUENCE_GAP_PX;
+        x = canFitBetween ? sourceRight + (targetLeft - sourceRight - previewNodeSize.width) / 2 : preferredAfterSourceX;
+        centerY = getNodeCenterY(sourceNode, sourceSize);
+    }
+    const position = {
+        x: Math.max(safeArea.x, snapToGrid(x)),
+        y: clampTopToSafeArea(snapToGrid(centerY - previewNodeSize.height / 2), previewNodeSize.height, safeArea)
+    };
+    if (!avoidSiblings) return position;
+    return avoidSiblingOverlap({
+        position,
+        nodeSize: previewNodeSize,
+        containerId: containerNode.id,
+        nodes,
+        ignoredNodeIds: new Set([
+            sourceNode.id,
+            ...targetNode ? [
+                targetNode.id
+            ] : []
+        ]),
+        safeArea
+    });
+}
+function createLoopSequencePreviewPlacement({ sourceNodeId, targetNodeId, reactFlowInstance, previewNodeSize = {
+    width: DEFAULT_NODE_SIZE,
+    height: DEFAULT_NODE_SIZE
+}, avoidSiblings = false }) {
+    const sourceNode = reactFlowInstance.getNode(sourceNodeId);
+    const targetNode = targetNodeId ? reactFlowInstance.getNode(targetNodeId) : void 0;
+    if (!sourceNode) return null;
+    const container = getContainerNode({
+        sourceNode,
+        targetNode
+    });
+    if (!container) return null;
+    const containerNode = reactFlowInstance.getNode(container.containerId);
+    if (!containerNode) return null;
+    const containerAbsolutePosition = getAbsolutePosition(containerNode, reactFlowInstance.getNodes());
+    const nodes = reactFlowInstance.getNodes();
+    const topLeft = getSequencePreviewTopLeft({
+        containerNode,
+        sourceNode,
+        targetNode,
+        nodes,
+        previewNodeSize,
+        mode: container.mode,
+        avoidSiblings
+    });
+    return {
+        containerId: container.containerId,
+        centerPosition: {
+            x: containerAbsolutePosition.x + topLeft.x + previewNodeSize.width / 2,
+            y: containerAbsolutePosition.y + topLeft.y + previewNodeSize.height / 2
+        }
+    };
+}
+function getLoopSequencePlacementFromPreviewGraph(previewNode, connections) {
+    const containerId = previewNode.parentId;
+    if (!containerId) return null;
+    const sourceConnections = connections.filter((connection)=>!connection.addNewNodeAsSource);
+    const targetConnections = connections.filter((connection)=>connection.addNewNodeAsSource);
+    if (1 !== sourceConnections.length || 1 !== targetConnections.length) return null;
+    const sourceNodeId = sourceConnections[0].existingNodeId;
+    const targetNodeId = targetConnections[0].existingNodeId;
+    return {
+        containerId,
+        sourceNodeId,
+        targetNodeId,
+        mode: sourceNodeId === containerId && targetNodeId === containerId ? 'first-child' : 'sequence'
+    };
+}
+function resolveLoopAddNodePreview({ sourceNodeId, sourceHandleId, reactFlowInstance }) {
+    const loopContinuation = resolveLoopContinuationTarget({
+        sourceNodeId,
+        sourceHandleId,
+        reactFlowInstance
+    });
+    if (loopContinuation?.type === 'ambiguous') return {
+        action: 'skip'
+    };
+    if (loopContinuation?.type !== 'target') return {
+        action: 'continue'
+    };
+    const loopSequencePlacement = createLoopSequencePreviewPlacement({
+        sourceNodeId,
+        targetNodeId: loopContinuation.targetNodeId,
+        reactFlowInstance,
+        avoidSiblings: !loopContinuation.removedEdge
+    });
+    return {
+        action: 'create-preview',
+        previewGraphOptions: {
+            ...loopSequencePlacement ? {
+                position: loopSequencePlacement.centerPosition,
+                positionMode: 'center',
+                containerId: loopSequencePlacement.containerId,
+                ...loopContinuation.removedEdge ? {
+                    data: {
+                        originalEdge: loopContinuation.removedEdge
+                    }
+                } : {}
+            } : {},
+            targetNodeId: loopContinuation.targetNodeId,
+            targetHandleId: loopContinuation.targetHandleId,
+            ...loopContinuation.removedEdge ? {
+                removedEdgeIds: [
+                    loopContinuation.removedEdge.id
+                ]
+            } : {}
+        }
+    };
+}
+function collectDownstreamNodeIds({ targetNodeId, containerId, nodesById, edges }) {
+    if (!targetNodeId || targetNodeId === containerId) return [];
+    const collectedIds = [];
+    const visitedIds = new Set();
+    let currentNodeId = targetNodeId;
+    while(currentNodeId && !visitedIds.has(currentNodeId)){
+        const currentNode = nodesById.get(currentNodeId);
+        if (!currentNode || currentNode.parentId !== containerId) break;
+        collectedIds.push(currentNodeId);
+        visitedIds.add(currentNodeId);
+        const nextEdge = edges.find((edge)=>{
+            if (isPreviewEdge(edge) || edge.source !== currentNodeId) return false;
+            const targetNode = nodesById.get(edge.target);
+            return targetNode?.parentId === containerId || edge.target === containerId;
+        });
+        if (!nextEdge || nextEdge.target === containerId) break;
+        currentNodeId = nextEdge.target;
+    }
+    return collectedIds;
+}
+function getCenteredMaterializedPosition({ containerNode, insertedNodeSize }) {
+    const currentContainerSize = getNodeDimensions(containerNode, {
+        width: 0,
+        height: 0
+    });
+    const currentSafeArea = getLoopChildSafeArea(containerNode);
+    const requiredContainerSize = {
+        width: snapUpToGrid(Math.max(currentContainerSize.width, currentSafeArea.padding.left + insertedNodeSize.width + currentSafeArea.padding.right)),
+        height: snapUpToGrid(Math.max(currentContainerSize.height, currentSafeArea.padding.top + insertedNodeSize.height + currentSafeArea.padding.bottom))
+    };
+    const grownSafeArea = getLoopChildSafeArea(containerNode, requiredContainerSize);
+    return centerInSafeArea(grownSafeArea, insertedNodeSize);
+}
+function resolveLoopSequenceMaterializedNodes({ nodes, edges, insertedNode, placement, getNodeSize = getNodeDimensions }) {
+    if (insertedNode.parentId !== placement.containerId) return null;
+    const nodesById = new Map(nodes.map((node)=>[
+            node.id,
+            node
+        ]));
+    const containerNode = nodesById.get(placement.containerId);
+    if (!containerNode) return null;
+    const insertedNodeSize = getNodeSize(insertedNode);
+    const safeArea = getLoopChildSafeArea(containerNode);
+    let positionedNode = insertedNode;
+    if ('first-child' === placement.mode) positionedNode = {
+        ...positionedNode,
+        position: getCenteredMaterializedPosition({
+            containerNode,
+            insertedNodeSize
+        })
+    };
+    else {
+        const sourceNode = nodesById.get(placement.sourceNodeId);
+        const targetNode = placement.targetNodeId ? nodesById.get(placement.targetNodeId) : void 0;
+        const sourceSize = getNodeSize(sourceNode ?? insertedNode);
+        const targetSize = getNodeSize(targetNode ?? insertedNode);
+        const sourceIsContainer = sourceNode?.id === placement.containerId;
+        const targetIsContainer = targetNode?.id === placement.containerId;
+        const sourceRight = sourceNode ? sourceNode.position.x + sourceSize.width : positionedNode.position.x;
+        const baseX = sourceNode && !sourceIsContainer ? sourceRight + LOOP_SEQUENCE_GAP_PX : targetNode && !targetIsContainer ? targetNode.position.x - insertedNodeSize.width - LOOP_SEQUENCE_GAP_PX : positionedNode.position.x;
+        const centerY = sourceNode && !sourceIsContainer ? getNodeCenterY(sourceNode, sourceSize) : targetNode && !targetIsContainer ? getNodeCenterY(targetNode, targetSize) : positionedNode.position.y + insertedNodeSize.height / 2;
+        positionedNode = {
+            ...positionedNode,
+            position: {
+                x: Math.max(safeArea.x, snapToGrid(baseX)),
+                y: clampTopToSafeArea(snapToGrid(centerY - insertedNodeSize.height / 2), insertedNodeSize.height, safeArea)
+            }
+        };
+    }
+    const downstreamNodeIds = new Set(collectDownstreamNodeIds({
+        targetNodeId: placement.targetNodeId,
+        containerId: placement.containerId,
+        nodesById,
+        edges
+    }));
+    const targetNode = placement.targetNodeId && placement.targetNodeId !== placement.containerId ? nodesById.get(placement.targetNodeId) : void 0;
+    const requiredTargetLeft = positionedNode.position.x + insertedNodeSize.width + LOOP_SEQUENCE_GAP_PX;
+    const downstreamShift = targetNode && targetNode.position.x < requiredTargetLeft ? snapUpToGrid(requiredTargetLeft - targetNode.position.x) : 0;
+    return nodes.map((node)=>{
+        if (node.id === positionedNode.id) return positionedNode;
+        if (downstreamShift > 0 && downstreamNodeIds.has(node.id)) return {
+            ...node,
+            position: {
+                ...node.position,
+                x: node.position.x + downstreamShift
+            }
+        };
+        return node;
+    });
+}
+export { createLoopSequencePreviewPlacement, getLoopSequencePlacementFromPreviewGraph, resolveLoopAddNodePreview, resolveLoopSequenceMaterializedNodes };

package/dist/canvas/components/LoopNode/LoopNode.types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/LoopNode/LoopNode.types.d.ts

@@ -0,0 +1,22 @@
+import type { Node, NodeProps } from '../../xyflow/react.ts';
+import type { SuggestionType } from '../../types';
+import type { ElementStatusValues } from '../../types/execution';
+import type { BaseNodeData } from '../BaseNode';
+import type { NodeAdornments } from '../BaseNode/BaseNode.types';
+import type { NodeToolbarConfig } from '../Toolbar';
+export type LoopNodeData = BaseNodeData;
+export interface LoopNodeResizeSize {
+    width: number;
+    height: number;
+}
+export interface LoopNodeConfig {
+    toolbarConfig?: NodeToolbarConfig | null;
+    adornments?: NodeAdornments;
+    executionStatusOverride?: ElementStatusValues;
+    suggestionType?: SuggestionType;
+}
+export interface LoopNodeProps extends NodeProps<Node<LoopNodeData>>, LoopNodeConfig {
+    onAddFirstChild?: () => void;
+    onResize?: (size: LoopNodeResizeSize) => void;
+}
+//# sourceMappingURL=LoopNode.types.d.ts.map

package/dist/canvas/components/LoopNode/LoopNode.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoopNode.types.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/LoopNode/LoopNode.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,0CAA0C,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,MAAM,YAAY,GAAG,YAAY,CAAC;AAExC,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACzC,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,uBAAuB,CAAC,EAAE,mBAAmB,CAAC;IAC9C,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,WAAW,aAAc,SAAQ,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,cAAc;IAClF,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAC/C"}

package/dist/canvas/components/LoopNode/LoopNodePreview.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    showCenteredContainerPreview: ()=>showCenteredContainerPreview
+});
+const createPreviewGraph_cjs_namespaceObject = require("../../utils/createPreviewGraph.cjs");
+const external_LoopNode_sequence_cjs_namespaceObject = require("./LoopNode.sequence.cjs");
+function showCenteredContainerPreview({ containerId, reactFlowInstance, previewHandles, trailingEdgeId }) {
+    const placement = (0, external_LoopNode_sequence_cjs_namespaceObject.createLoopSequencePreviewPlacement)({
+        sourceNodeId: containerId,
+        targetNodeId: containerId,
+        reactFlowInstance
+    });
+    if (!placement) return;
+    (0, createPreviewGraph_cjs_namespaceObject.showPreviewGraph)({
+        sourceNodeId: containerId,
+        sourceHandleId: previewHandles.sourceHandleId,
+        reactFlowInstance,
+        position: placement.centerPosition,
+        positionMode: 'center',
+        handlePosition: previewHandles.sourceHandlePosition,
+        targetNodeId: containerId,
+        targetHandleId: previewHandles.targetHandleId,
+        containerId: placement.containerId,
+        trailingEdgeId
+    });
+}
+exports.showCenteredContainerPreview = __webpack_exports__.showCenteredContainerPreview;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "showCenteredContainerPreview"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/LoopNode/LoopNodePreview.d.ts

@@ -0,0 +1,9 @@
+import type { ReactFlowInstance } from '../../xyflow/react.ts';
+import type { LoopPreviewConnectionHandles } from './LoopNode.helpers';
+export declare function showCenteredContainerPreview({ containerId, reactFlowInstance, previewHandles, trailingEdgeId, }: {
+    containerId: string;
+    reactFlowInstance: ReactFlowInstance;
+    previewHandles: LoopPreviewConnectionHandles;
+    trailingEdgeId?: string;
+}): void;
+//# sourceMappingURL=LoopNodePreview.d.ts.map

package/dist/canvas/components/LoopNode/LoopNodePreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoopNodePreview.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/LoopNode/LoopNodePreview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAElF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAGvE,wBAAgB,4BAA4B,CAAC,EAC3C,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,cAAc,GACf,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,cAAc,EAAE,4BAA4B,CAAC;IAC7C,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,QAoBA"}

package/dist/canvas/components/LoopNode/LoopNodePreview.js

@@ -0,0 +1,23 @@
+import { showPreviewGraph } from "../../utils/createPreviewGraph.js";
+import { createLoopSequencePreviewPlacement } from "./LoopNode.sequence.js";
+function showCenteredContainerPreview({ containerId, reactFlowInstance, previewHandles, trailingEdgeId }) {
+    const placement = createLoopSequencePreviewPlacement({
+        sourceNodeId: containerId,
+        targetNodeId: containerId,
+        reactFlowInstance
+    });
+    if (!placement) return;
+    showPreviewGraph({
+        sourceNodeId: containerId,
+        sourceHandleId: previewHandles.sourceHandleId,
+        reactFlowInstance,
+        position: placement.centerPosition,
+        positionMode: 'center',
+        handlePosition: previewHandles.sourceHandlePosition,
+        targetNodeId: containerId,
+        targetHandleId: previewHandles.targetHandleId,
+        containerId: placement.containerId,
+        trailingEdgeId
+    });
+}
+export { showCenteredContainerPreview };

package/dist/canvas/components/LoopNode/index.cjs

@@ -0,0 +1,79 @@
+"use strict";
+var __webpack_modules__ = {
+    "./LoopCanvasNode" (module) {
+        module.exports = require("./LoopCanvasNode.cjs");
+    },
+    "./LoopNode?d3ac" (module) {
+        module.exports = require("./LoopNode.cjs");
+    },
+    "./LoopNode.helpers" (module) {
+        module.exports = require("./LoopNode.helpers.cjs");
+    },
+    "./LoopNode.types" (module) {
+        module.exports = require("./LoopNode.types.cjs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _LoopCanvasNode__rspack_import_0 = __webpack_require__("./LoopCanvasNode");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _LoopCanvasNode__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_LoopCanvasNode__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _LoopNode__rspack_import_1 = __webpack_require__("./LoopNode?d3ac");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _LoopNode__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_LoopNode__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _LoopNode_helpers__rspack_import_2 = __webpack_require__("./LoopNode.helpers");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _LoopNode_helpers__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_LoopNode_helpers__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _LoopNode_types__rspack_import_3 = __webpack_require__("./LoopNode.types");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _LoopNode_types__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_LoopNode_types__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/LoopNode/index.d.ts

@@ -0,0 +1,5 @@
+export * from './LoopCanvasNode';
+export * from './LoopNode';
+export * from './LoopNode.helpers';
+export * from './LoopNode.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/canvas/components/LoopNode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/LoopNode/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC"}

package/dist/canvas/components/LoopNode/index.js

@@ -0,0 +1,4 @@
+export * from "./LoopCanvasNode.js";
+export * from "./LoopNode.js";
+export * from "./LoopNode.helpers.js";
+export * from "./LoopNode.types.js";

package/dist/canvas/components/NodeViewportOverlay.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    NodeViewportOverlay: ()=>NodeViewportOverlay
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const react_cjs_namespaceObject = require("../xyflow/react.cjs");
+const NODE_VIEWPORT_OVERLAY_Z_INDEX = {
+    nodeHandleAffordance: 1002,
+    nodeToolbar: 1003
+};
+function NodeViewportOverlay({ nodeId, anchor, layer, children }) {
+    const internalNode = (0, react_cjs_namespaceObject.useInternalNode)(nodeId);
+    const positionAbsolute = internalNode?.internals.positionAbsolute;
+    const width = anchor?.width ?? internalNode?.measured?.width ?? internalNode?.width;
+    const height = anchor?.height ?? internalNode?.measured?.height ?? internalNode?.height;
+    if (!positionAbsolute || null == width || null == height) return children;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_cjs_namespaceObject.ViewportPortal, {
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+            className: "absolute pointer-events-none",
+            style: {
+                position: 'absolute',
+                left: positionAbsolute.x + (anchor?.left ?? 0),
+                top: positionAbsolute.y + (anchor?.top ?? 0),
+                width,
+                height,
+                transform: anchor?.transform,
+                zIndex: layer ? NODE_VIEWPORT_OVERLAY_Z_INDEX[layer] : void 0
+            },
+            children: children
+        })
+    });
+}
+exports.NodeViewportOverlay = __webpack_exports__.NodeViewportOverlay;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "NodeViewportOverlay"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/NodeViewportOverlay.d.ts

@@ -0,0 +1,22 @@
+import type { CSSProperties, ReactNode } from 'react';
+declare const NODE_VIEWPORT_OVERLAY_Z_INDEX: {
+    readonly nodeHandleAffordance: 1002;
+    readonly nodeToolbar: 1003;
+};
+type NodeViewportOverlayLayer = keyof typeof NODE_VIEWPORT_OVERLAY_Z_INDEX;
+export type NodeViewportOverlayAnchor = {
+    left?: number;
+    top?: number;
+    width?: number;
+    height?: number;
+    transform?: CSSProperties['transform'];
+};
+export type NodeViewportOverlayProps = {
+    nodeId: string;
+    anchor?: NodeViewportOverlayAnchor;
+    layer?: NodeViewportOverlayLayer;
+    children: ReactNode;
+};
+export declare function NodeViewportOverlay({ nodeId, anchor, layer, children }: NodeViewportOverlayProps): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+export {};
+//# sourceMappingURL=NodeViewportOverlay.d.ts.map