@flowgram.ai/free-layout-core 0.1.0-alpha.35 → 0.1.0-alpha.37

package/dist/index.js

@@ -365,7 +365,14 @@ var WorkflowPortEntity = class extends import_core4.Entity {
     );
   }
   isHovered(x, y) {
-    return this.bounds.contains(x, y);
+    const { point } = this;
+    const size = this._size || { width: PORT_SIZE, height: PORT_SIZE };
+    const halfWidth = size.width / 2;
+    const halfHeight = size.height / 2;
+    if (size.width <= 0 || size.height <= 0) {
+      return false;
+    }
+    return x >= point.x - halfWidth && x <= point.x + halfWidth && y >= point.y - halfHeight && y <= point.y + halfHeight;
   }
   /**
    * 相对节点左上角的位置
@@ -466,6 +473,7 @@ var WorkflowNodePortsData = class extends import_core5.EntityData {
     this._staticPorts = [];
     /** 存储 port 实体的 id，用于判断 port 是否存在 */
     this._portIDSet = /* @__PURE__ */ new Set();
+    this._portDisposeIDSet = /* @__PURE__ */ new Set();
     this.entity = entity;
     const meta = entity.getNodeMeta();
     const defaultPorts = meta.useDynamicPort ? [] : [{ type: "input" }, { type: "output" }];
@@ -552,6 +560,7 @@ var WorkflowNodePortsData = class extends import_core5.EntityData {
       });
       ports.forEach((port) => this.updatePortEntity(port));
       this._prePorts = ports;
+      this.clearPortsCache();
       this.fireChange();
     }
     this.allPorts.forEach((port) => {
@@ -564,19 +573,28 @@ var WorkflowNodePortsData = class extends import_core5.EntityData {
    * 获取所有 port entities
    */
   get allPorts() {
-    return Array.from(this._portIDSet).map((portId) => this.getPortEntity(portId)).filter(Boolean);
+    if (!this._allPortsCache) {
+      this._allPortsCache = Array.from(this._portIDSet).map((portId) => this.getPortEntity(portId)).filter(Boolean);
+    }
+    return this._allPortsCache;
   }
   /**
    * 获取输入点位
    */
   get inputPorts() {
-    return this.allPorts.filter((port) => port.portType === "input");
+    if (!this._inputPortsCache) {
+      this._inputPortsCache = this.allPorts.filter((port) => port.portType === "input");
+    }
+    return this._inputPortsCache;
   }
   /**
    * 获取输出点位
    */
   get outputPorts() {
-    return this.allPorts.filter((port) => port.portType === "output");
+    if (!this._outputPortsCache) {
+      this._outputPortsCache = this.allPorts.filter((port) => port.portType === "output");
+    }
+    return this._outputPortsCache;
   }
   /**
    * 获取输入点位置
@@ -588,7 +606,7 @@ var WorkflowNodePortsData = class extends import_core5.EntityData {
    * 获取输出点位置
    */
   get outputPoints() {
-    return this.inputPorts.map((port) => port.point);
+    return this.outputPorts.map((port) => port.point);
   }
   /**
    * 根据 key 获取 输入点位置
@@ -617,6 +635,11 @@ var WorkflowNodePortsData = class extends import_core5.EntityData {
   getPortId(portType, portKey = "") {
     return getPortEntityId(this.entity, portType, portKey);
   }
+  clearPortsCache() {
+    this._allPortsCache = void 0;
+    this._inputPortsCache = void 0;
+    this._outputPortsCache = void 0;
+  }
   /**
    * 创建 port 实体
    */
@@ -630,10 +653,18 @@ var WorkflowNodePortsData = class extends import_core5.EntityData {
         ...portInfo
       });
     }
-    portEntity.onDispose(() => {
-      this._portIDSet.delete(id);
-    });
-    this._portIDSet.add(id);
+    if (!this._portDisposeIDSet.has(id)) {
+      this._portDisposeIDSet.add(id);
+      portEntity.onDispose(() => {
+        this._portIDSet.delete(id);
+        this._portDisposeIDSet.delete(id);
+        this.clearPortsCache();
+      });
+    }
+    if (!this._portIDSet.has(id)) {
+      this._portIDSet.add(id);
+      this.clearPortsCache();
+    }
     return portEntity;
   }
   /**
@@ -1491,7 +1522,6 @@ var import_document10 = require("@flowgram.ai/document");
 var import_core15 = require("@flowgram.ai/core");
 
 // src/workflow-lines-manager.ts
-var import_lodash_es3 = require("lodash-es");
 var import_inversify3 = require("inversify");
 var import_utils12 = require("@flowgram.ai/utils");
 var import_document6 = require("@flowgram.ai/document");
@@ -1612,6 +1642,12 @@ var WorkflowDocumentOptionsDefault = {
 };
 
 // src/workflow-lines-manager.ts
+var NODE_HIT_CELL_SIZE = 512;
+var LINE_HIT_CELL_SIZE = 512;
+var PORT_NODE_BOUNDS_PADDING = 96;
+var NODE_INDEX_MIN_SIZE = 128;
+var LINE_INDEX_MIN_SIZE = 128;
+var MAX_SPATIAL_CELLS_PER_ITEM = 64;
 var WorkflowLinesManager = class {
   constructor() {
     this.toDispose = new import_utils12.DisposableCollection();
@@ -1635,11 +1671,35 @@ var WorkflowLinesManager = class {
     this.isDrawing = false;
   }
   init(doc) {
+    if (this.document === doc) {
+      return;
+    }
     this.document = doc;
+    this.toDispose.pushAll([
+      this.entityManager.onEntityChange((entityType) => {
+        if (entityType === WorkflowNodeEntity.type) {
+          this.invalidateNodeHitCaches();
+        }
+        if (entityType === WorkflowLineEntity.type || entityType === WorkflowPortEntity.type) {
+          this.invalidateLineHitCache();
+          this.outsidePortNodesCache = void 0;
+        }
+      }),
+      this.entityManager.onEntityDataChange(({ entityDataType }) => {
+        if (entityDataType === import_document6.FlowNodeTransformData.type) {
+          this.invalidateSpatialHitCaches();
+        }
+      })
+    ]);
   }
   forceUpdate() {
     this.onForceUpdateEmitter.fire();
   }
+  invalidateSortedNodesCache() {
+    this.sortedNodesCache = void 0;
+    this.sortedNodesCacheVersion = void 0;
+    this.invalidateNodeHitCaches();
+  }
   get lineType() {
     return this._lineType;
   }
@@ -1668,6 +1728,7 @@ var WorkflowLinesManager = class {
     }
     if (newType !== this._lineType) {
       this._lineType = newType;
+      this.lineSpatialCache = void 0;
       this.getAllLines().forEach((line) => {
         line.getData(WorkflowLineRenderData).update();
       });
@@ -1826,17 +1887,26 @@ var WorkflowLinesManager = class {
    */
   getCloseInLineFromMousePos(mousePos, minDistance = LINE_HOVER_DISTANCE) {
     let targetLine, targetLineDist;
-    this.getAllLines().forEach((line) => {
+    const lines = this.getLineHitCandidates(mousePos, minDistance);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!this.isPointInBounds(mousePos, line.bounds, minDistance)) {
+        continue;
+      }
       const dist = line.getHoverDist(mousePos);
-      if (dist <= minDistance && (!targetLineDist || targetLineDist >= dist)) {
+      if (dist <= minDistance && (targetLineDist === void 0 || targetLineDist >= dist)) {
         targetLineDist = dist;
         targetLine = line;
       }
-    });
+    }
     return targetLine;
   }
   dispose() {
     this.portLineMap.clear();
+    this.sortedNodeSpatialCache = void 0;
+    this.hoverNodeSpatialCache = void 0;
+    this.lineSpatialCache = void 0;
+    this.outsidePortNodesCache = void 0;
     this.toDispose.dispose();
   }
   get disposed() {
@@ -1951,39 +2021,45 @@ var WorkflowLinesManager = class {
    * @param pos
    */
   getPortFromMousePos(pos, portType) {
-    const allNodes = this.getSortedNodes().reverse();
-    const allPorts = allNodes.map((node) => {
-      if (!portType) {
-        return node.ports.allPorts;
-      }
-      return portType === "input" ? node.ports.inputPorts : node.ports.outputPorts;
-    }).flat();
-    const targetPort = allPorts.find((port) => port.isHovered(pos.x, pos.y));
-    if (targetPort) {
-      const containNodes = this.getContainNodesFromMousePos(pos);
-      const targetNode = (0, import_lodash_es3.last)(containNodes);
-      if (targetNode && targetNode !== targetPort.node) {
-        return;
+    return this.getHoveredPortFromSortedNodes(pos, this.getSortedNodes(), portType);
+  }
+  getPortsFromMousePos(pos) {
+    return this.getHoveredPortsFromSortedNodes(pos, this.getSortedNodes(), void 0, {
+      collectBoth: true
+    });
+  }
+  getNodeAndPortFromMousePos(pos, portType) {
+    const sortedNodes = this.getSortedNodes();
+    const nodeHitInfo = this.getNodeHitInfoFromSortedNodes(
+      pos,
+      sortedNodes,
+      this.selectService.selection
+    );
+    const ports = this.getHoveredPortsFromSortedNodes(pos, sortedNodes, portType, {
+      topCoverNode: nodeHitInfo.topCoverNode
+    });
+    return {
+      node: nodeHitInfo.topNode,
+      port: ports.port
+    };
+  }
+  getHoverNodeFromMousePos(pos) {
+    const nodes = this.getHoverNodes();
+    const candidates = this.getHoverNodeHitCandidates(pos, nodes);
+    for (let i = 0; i < candidates.length; i++) {
+      const node = candidates[i];
+      const { bounds } = node.getData(import_document6.FlowNodeTransformData);
+      if (this.isPointInBounds(pos, bounds)) {
+        return node;
       }
     }
-    return targetPort;
   }
   /**
    * 根据鼠标位置找到 node
    * @param pos - 鼠标位置
    */
   getNodeFromMousePos(pos) {
-    const { selection } = this.selectService;
-    const containNodes = this.getContainNodesFromMousePos(pos);
-    if (selection?.length) {
-      const filteredNodes = containNodes.filter(
-        (node) => selection.some((_node) => node.id === _node.id)
-      );
-      if (filteredNodes?.length) {
-        return (0, import_lodash_es3.last)(filteredNodes);
-      }
-    }
-    return (0, import_lodash_es3.last)(containNodes);
+    return this.getTopNodeFromSortedNodes(pos, this.getSortedNodes(), this.selectService.selection);
   }
   registerContribution(factory) {
     this.contributionFactories.push(factory);
@@ -1993,19 +2069,352 @@ var WorkflowLinesManager = class {
     line.addData(WorkflowLineRenderData);
   }
   getSortedNodes() {
-    return this.document.getAllNodes().sort((a, b) => this.getNodeIndex(a) - this.getNodeIndex(b));
+    const nodeVersion = this.entityManager.getEntityVersion(WorkflowNodeEntity);
+    if (this.sortedNodesCache && this.sortedNodesCacheVersion === nodeVersion) {
+      return this.sortedNodesCache;
+    }
+    this.sortedNodesCache = [...this.document.getAllNodes()].sort(
+      (a, b) => this.getNodeIndex(a) - this.getNodeIndex(b)
+    );
+    this.sortedNodesCacheVersion = nodeVersion;
+    this.sortedNodeSpatialCache = void 0;
+    this.outsidePortNodesCache = void 0;
+    return this.sortedNodesCache;
+  }
+  invalidateNodeHitCaches() {
+    this.sortedNodeSpatialCache = void 0;
+    this.hoverNodeSpatialCache = void 0;
+    this.outsidePortNodesCache = void 0;
+  }
+  invalidateLineHitCache() {
+    this.lineSpatialCache = void 0;
+  }
+  invalidateSpatialHitCaches() {
+    this.invalidateNodeHitCaches();
+    this.invalidateLineHitCache();
+  }
+  getHoveredPortFromSortedNodes(pos, sortedNodes, portType) {
+    return this.getHoveredPortsFromSortedNodes(pos, sortedNodes, portType).port;
+  }
+  getHoveredPortsFromSortedNodes(pos, sortedNodes, portType, options = {}) {
+    let inputPort;
+    let outputPort;
+    let anyPort;
+    const { collectBoth = false } = options;
+    const needInput = !portType || portType === "input";
+    const needOutput = !portType || portType === "output";
+    const needAny = !portType && !collectBoth;
+    const candidates = this.getSortedNodeHitCandidates(pos, sortedNodes, PORT_NODE_BOUNDS_PADDING);
+    const checkedNodes = candidates.length === sortedNodes.length ? void 0 : new Set(candidates);
+    for (let i = candidates.length - 1; i >= 0; i--) {
+      const node = candidates[i];
+      if (!this.isPointNearNodePorts(pos, node)) {
+        continue;
+      }
+      const result = this.collectHoveredPorts(node.ports.allPorts, pos, {
+        needInput,
+        needOutput,
+        needAny,
+        inputPort,
+        outputPort,
+        anyPort
+      });
+      inputPort = result.inputPort;
+      outputPort = result.outputPort;
+      anyPort = result.anyPort;
+      if (portType === "input" && inputPort || portType === "output" && outputPort || !portType && (collectBoth ? inputPort && outputPort : anyPort)) {
+        break;
+      }
+    }
+    if (checkedNodes && !(portType === "input" && inputPort || portType === "output" && outputPort || !portType && (collectBoth ? inputPort && outputPort : anyPort))) {
+      const outsidePortNodes = this.getOutsidePortNodes(sortedNodes);
+      for (let i = outsidePortNodes.length - 1; i >= 0; i--) {
+        const node = outsidePortNodes[i];
+        if (checkedNodes.has(node)) {
+          continue;
+        }
+        const result = this.collectHoveredPorts(node.ports.allPorts, pos, {
+          needInput,
+          needOutput,
+          needAny,
+          inputPort,
+          outputPort,
+          anyPort
+        });
+        inputPort = result.inputPort;
+        outputPort = result.outputPort;
+        anyPort = result.anyPort;
+        if (portType === "input" && inputPort || portType === "output" && outputPort || !portType && (collectBoth ? inputPort && outputPort : anyPort)) {
+          break;
+        }
+      }
+    }
+    const needCoverCheck = inputPort || outputPort || anyPort;
+    const topCoverNode = needCoverCheck ? options.topCoverNode || this.getNodeHitInfoFromSortedNodes(pos, sortedNodes).topCoverNode : void 0;
+    inputPort = this.filterCoveredPort(inputPort, topCoverNode);
+    outputPort = this.filterCoveredPort(outputPort, topCoverNode);
+    anyPort = this.filterCoveredPort(anyPort, topCoverNode);
+    return {
+      input: inputPort,
+      output: outputPort,
+      port: portType === "input" ? inputPort : portType === "output" ? outputPort : anyPort
+    };
   }
-  /** 获取鼠标坐标位置的所有节点（stackIndex 从小到大排序） */
-  getContainNodesFromMousePos(pos) {
-    const allNodes = this.getSortedNodes();
+  collectHoveredPorts(ports, pos, options) {
+    let { inputPort, outputPort, anyPort } = options;
+    for (let i = 0; i < ports.length; i++) {
+      const port = ports[i];
+      if ((!options.needAny || anyPort) && (!options.needInput || inputPort) && (!options.needOutput || outputPort)) {
+        break;
+      }
+      if (port.isHovered(pos.x, pos.y)) {
+        if (!anyPort && options.needAny) {
+          anyPort = port;
+        }
+        if (!inputPort && options.needInput && port.portType === "input") {
+          inputPort = port;
+        }
+        if (!outputPort && options.needOutput && port.portType === "output") {
+          outputPort = port;
+        }
+      }
+    }
+    return {
+      inputPort,
+      outputPort,
+      anyPort
+    };
+  }
+  filterCoveredPort(port, topCoverNode) {
+    if (port && topCoverNode && topCoverNode !== port.node) {
+      return void 0;
+    }
+    return port;
+  }
+  getTopNodeFromSortedNodes(pos, sortedNodes, selection) {
+    return this.getNodeHitInfoFromSortedNodes(pos, sortedNodes, selection).topNode;
+  }
+  getNodeHitInfoFromSortedNodes(pos, sortedNodes, selection) {
     const zoom = this.entityManager.getEntity(import_core12.PlaygroundConfigEntity)?.config?.zoom || 1;
-    const containNodes = allNodes.map((node) => {
+    const padding = 4 / zoom;
+    const selectedIDs = selection?.length ? new Set(selection.map((node) => node.id)) : void 0;
+    const candidates = this.getSortedNodeHitCandidates(pos, sortedNodes, padding);
+    let topCoverNode;
+    for (let i = candidates.length - 1; i >= 0; i--) {
+      const node = candidates[i];
       const { bounds } = node.getData(import_document6.FlowNodeTransformData);
-      if (bounds.clone().pad(4 / zoom).contains(pos.x, pos.y)) {
-        return node;
+      if (!this.isPointInBounds(pos, bounds, padding)) {
+        continue;
       }
-    }).filter(Boolean);
-    return containNodes;
+      if (!topCoverNode) {
+        topCoverNode = node;
+      }
+      if (!selectedIDs) {
+        return {
+          topCoverNode,
+          topNode: node
+        };
+      }
+      if (selectedIDs.has(node.id)) {
+        return {
+          topCoverNode,
+          topNode: node
+        };
+      }
+    }
+    return {
+      topCoverNode,
+      topNode: topCoverNode
+    };
+  }
+  getHoverNodeHitCandidates(pos, nodes) {
+    if (nodes.length < NODE_INDEX_MIN_SIZE) {
+      return nodes;
+    }
+    const nodeVersion = this.entityManager.getEntityVersion(WorkflowNodeEntity);
+    const transformVersion = this.entityManager.getEntityDataVersion(import_document6.FlowNodeTransformData);
+    const activatedID = this.selectService.activatedNode?.id;
+    if (!this.hoverNodeSpatialCache || this.hoverNodeSpatialCache.nodeVersion !== nodeVersion || this.hoverNodeSpatialCache.transformVersion !== transformVersion || this.hoverNodeSpatialCache.activatedID !== activatedID || this.hoverNodeSpatialCache.nodes !== nodes) {
+      this.hoverNodeSpatialCache = {
+        nodeVersion,
+        transformVersion,
+        activatedID,
+        nodes,
+        index: this.createSpatialIndex(
+          nodes,
+          (node) => node.getData(import_document6.FlowNodeTransformData).bounds,
+          NODE_HIT_CELL_SIZE
+        )
+      };
+    }
+    return this.querySpatialIndex(this.hoverNodeSpatialCache.index, pos);
+  }
+  getSortedNodeHitCandidates(pos, sortedNodes, padding = 0) {
+    if (sortedNodes.length < NODE_INDEX_MIN_SIZE) {
+      return sortedNodes;
+    }
+    const nodeVersion = this.entityManager.getEntityVersion(WorkflowNodeEntity);
+    const transformVersion = this.entityManager.getEntityDataVersion(import_document6.FlowNodeTransformData);
+    if (!this.sortedNodeSpatialCache || this.sortedNodeSpatialCache.nodeVersion !== nodeVersion || this.sortedNodeSpatialCache.transformVersion !== transformVersion || this.sortedNodeSpatialCache.nodes !== sortedNodes) {
+      this.sortedNodeSpatialCache = {
+        nodeVersion,
+        transformVersion,
+        nodes: sortedNodes,
+        index: this.createSpatialIndex(
+          sortedNodes,
+          (node) => node.getData(import_document6.FlowNodeTransformData).bounds,
+          NODE_HIT_CELL_SIZE
+        )
+      };
+    }
+    return this.querySpatialIndex(this.sortedNodeSpatialCache.index, pos, padding);
+  }
+  getLineHitCandidates(pos, padding) {
+    const lines = this.getAllLines();
+    if (lines.length < LINE_INDEX_MIN_SIZE) {
+      return lines;
+    }
+    const lineVersion = this.entityManager.getEntityVersion(WorkflowLineEntity);
+    const portVersion = this.entityManager.getEntityVersion(WorkflowPortEntity);
+    const transformVersion = this.entityManager.getEntityDataVersion(import_document6.FlowNodeTransformData);
+    if (!this.lineSpatialCache || this.lineSpatialCache.lineVersion !== lineVersion || this.lineSpatialCache.portVersion !== portVersion || this.lineSpatialCache.transformVersion !== transformVersion) {
+      this.lineSpatialCache = {
+        lineVersion,
+        portVersion,
+        transformVersion,
+        index: this.createSpatialIndex(lines, (line) => line.bounds, LINE_HIT_CELL_SIZE)
+      };
+    }
+    return this.querySpatialIndex(this.lineSpatialCache.index, pos, padding);
+  }
+  createSpatialIndex(items, getBounds, cellSize) {
+    const index = {
+      cellSize,
+      cells: /* @__PURE__ */ new Map(),
+      overflowItems: [],
+      order: /* @__PURE__ */ new Map()
+    };
+    items.forEach((item, itemIndex) => {
+      index.order.set(item, itemIndex);
+      const bounds = getBounds(item);
+      if (!this.canIndexBounds(bounds)) {
+        index.overflowItems.push(item);
+        return;
+      }
+      const minCellX = this.getSpatialCell(bounds.x, cellSize);
+      const maxCellX = this.getSpatialCell(bounds.right, cellSize);
+      const minCellY = this.getSpatialCell(bounds.y, cellSize);
+      const maxCellY = this.getSpatialCell(bounds.bottom, cellSize);
+      const cellCount = (maxCellX - minCellX + 1) * (maxCellY - minCellY + 1);
+      if (cellCount > MAX_SPATIAL_CELLS_PER_ITEM) {
+        index.overflowItems.push(item);
+        return;
+      }
+      for (let x = minCellX; x <= maxCellX; x++) {
+        for (let y = minCellY; y <= maxCellY; y++) {
+          const key = this.getSpatialCellKey(x, y);
+          let cellItems = index.cells.get(key);
+          if (!cellItems) {
+            cellItems = [];
+            index.cells.set(key, cellItems);
+          }
+          cellItems.push(item);
+        }
+      }
+    });
+    return index;
+  }
+  querySpatialIndex(index, pos, padding = 0) {
+    const minCellX = this.getSpatialCell(pos.x - padding, index.cellSize);
+    const maxCellX = this.getSpatialCell(pos.x + padding, index.cellSize);
+    const minCellY = this.getSpatialCell(pos.y - padding, index.cellSize);
+    const maxCellY = this.getSpatialCell(pos.y + padding, index.cellSize);
+    const candidates = [];
+    const candidateSet = /* @__PURE__ */ new Set();
+    const pushCandidate = (item) => {
+      if (candidateSet.has(item)) {
+        return;
+      }
+      candidateSet.add(item);
+      candidates.push(item);
+    };
+    for (let x = minCellX; x <= maxCellX; x++) {
+      for (let y = minCellY; y <= maxCellY; y++) {
+        const cellItems = index.cells.get(this.getSpatialCellKey(x, y));
+        if (cellItems) {
+          cellItems.forEach(pushCandidate);
+        }
+      }
+    }
+    index.overflowItems.forEach(pushCandidate);
+    return candidates.sort((a, b) => (index.order.get(a) ?? 0) - (index.order.get(b) ?? 0));
+  }
+  getSpatialCell(value, cellSize) {
+    return Math.floor(value / cellSize);
+  }
+  getSpatialCellKey(x, y) {
+    return `${x}:${y}`;
+  }
+  canIndexBounds(bounds) {
+    return Number.isFinite(bounds.x) && Number.isFinite(bounds.y) && Number.isFinite(bounds.width) && Number.isFinite(bounds.height) && bounds.width > 0 && bounds.height > 0;
+  }
+  isPointNearNodePorts(pos, node) {
+    const { bounds } = node.getData(import_document6.FlowNodeTransformData);
+    return this.isPointInBounds(pos, bounds, PORT_NODE_BOUNDS_PADDING);
+  }
+  hasPortOutsideNodeBounds(node) {
+    const { bounds } = node.getData(import_document6.FlowNodeTransformData);
+    return node.ports.allPorts.some((port) => {
+      if (port.targetElement) {
+        return true;
+      }
+      return !this.isPointInBounds(port.point, bounds, PORT_NODE_BOUNDS_PADDING);
+    });
+  }
+  getOutsidePortNodes(sortedNodes) {
+    const nodeVersion = this.entityManager.getEntityVersion(WorkflowNodeEntity);
+    const portVersion = this.entityManager.getEntityVersion(WorkflowPortEntity);
+    const transformVersion = this.entityManager.getEntityDataVersion(import_document6.FlowNodeTransformData);
+    if (this.outsidePortNodesCache && this.outsidePortNodesCache.nodeVersion === nodeVersion && this.outsidePortNodesCache.portVersion === portVersion && this.outsidePortNodesCache.transformVersion === transformVersion && this.outsidePortNodesCache.sortedNodes === sortedNodes) {
+      return this.outsidePortNodesCache.outsideNodes;
+    }
+    const outsideNodes = sortedNodes.filter((node) => this.hasPortOutsideNodeBounds(node));
+    this.outsidePortNodesCache = {
+      nodeVersion,
+      portVersion,
+      transformVersion,
+      sortedNodes,
+      outsideNodes
+    };
+    return outsideNodes;
+  }
+  getHoverNodes() {
+    const nodeVersion = this.entityManager.getEntityVersion(WorkflowNodeEntity);
+    const activatedID = this.selectService.activatedNode?.id;
+    if (this.hoverNodesCache && this.hoverNodesCacheVersion === nodeVersion && this.hoverNodesCacheActivatedID === activatedID) {
+      return this.hoverNodesCache;
+    }
+    const nodes = this.document.getAllNodes().filter(
+      (node) => node.id !== "root" && node.flowNodeType !== import_document6.FlowNodeBaseType.ROOT && node.flowNodeType !== import_document6.FlowNodeBaseType.GROUP
+    ).reverse();
+    if (activatedID) {
+      const activatedIndex = nodes.findIndex((node) => node.id === activatedID);
+      if (activatedIndex > 0) {
+        const [activatedNode] = nodes.splice(activatedIndex, 1);
+        nodes.unshift(activatedNode);
+      }
+    }
+    this.hoverNodesCache = nodes;
+    this.hoverNodesCacheVersion = nodeVersion;
+    this.hoverNodesCacheActivatedID = activatedID;
+    this.hoverNodeSpatialCache = void 0;
+    return this.hoverNodesCache;
+  }
+  isPointInBounds(pos, bounds, padding = 0) {
+    if (bounds.width + padding * 2 <= 0 || bounds.height + padding * 2 <= 0) {
+      return false;
+    }
+    return pos.x >= bounds.x - padding && pos.x <= bounds.right + padding && pos.y >= bounds.y - padding && pos.y <= bounds.bottom + padding;
   }
   getNodeIndex(node) {
     const nodeRenderData = node.getData(import_document6.FlowNodeRenderData);
@@ -3407,15 +3816,15 @@ var WorkflowDragService = class {
   }
   updateDrawingLine(isDrawingTo, line, dragPos, originLine) {
     let hasError = false;
-    const mouseNode = this.linesManager.getNodeFromMousePos(dragPos);
     let toNode;
     let toPort;
     let fromPort;
     let fromNode;
     if (isDrawingTo) {
+      const mouseHitInfo = this.linesManager.getNodeAndPortFromMousePos(dragPos, "input");
       fromPort = line.fromPort;
-      toNode = mouseNode;
-      toPort = this.linesManager.getPortFromMousePos(dragPos, "input");
+      toNode = mouseHitInfo.node;
+      toPort = mouseHitInfo.port;
       if (toNode && this.canBuildContainerLine(toNode, dragPos)) {
         toPort = this.getNearestPort(toNode, dragPos, "input");
         hasError = this.checkDraggingPort(isDrawingTo, line, toNode, toPort, originLine).hasError;
@@ -3442,9 +3851,10 @@ var WorkflowDragService = class {
         };
       }
     } else {
+      const mouseHitInfo = this.linesManager.getNodeAndPortFromMousePos(dragPos, "output");
       toPort = line.toPort;
-      fromNode = mouseNode;
-      fromPort = this.linesManager.getPortFromMousePos(dragPos, "output");
+      fromNode = mouseHitInfo.node;
+      fromPort = mouseHitInfo.port;
       if (fromNode && this.canBuildContainerLine(fromNode, dragPos)) {
         fromPort = this.getNearestPort(fromNode, dragPos, "output");
         hasError = this.checkDraggingPort(